-.. Introducción a la importancia de la recolección de basura y sus
- principales técnicas, con sus ventajas y desventajas. También se da
- un breve recorrido sobre el estado del arte.
- ESTADO: TERMINADO
-
-
.. _gc:
Recolección de basura
apuntado no es el mismo tipo o porque la memoria ya ha sido liberada. Al
ser desreferenciado, los resultados son impredecibles, el programa podría
abortarse por una violación de segmento o podrían pasar peores cosas si el
- área de memoria fue realocada para almacenar otro objeto.
+ área de memoria fue re-asignada para almacenar otro objeto.
La recolección de basura nació junto a Lisp_ a finales de 1950 y en los
siguientes años estuvo asociada principalmente a lenguajes funcionales, pero
investigaciones).
En las primeras implementaciones de recolectores de basura la penalización en
-la eficiencia del programa se volvía prohibitiva para muchas aplicaciones. Es
+el rendimiento del programa se volvía prohibitiva para muchas aplicaciones. Es
por esto que hubo bastante resistencia a la utilización de recolectores de
basura, pero el avance en la investigación fue haciendo que cada vez sea una
-alternativa más viable al manejo manual de memoria, incluso para apliaciones
-con altos requerimientos de eficiencia. En la actualidad un programa que
-utiliza un recolector moderno puede ser comparable en eficiencia con uno que
+alternativa más viable al manejo manual de memoria, incluso para aplicaciones
+con altos requerimientos de rendimiento. En la actualidad un programa que
+utiliza un recolector moderno puede ser comparable en rendimiento con uno que
utiliza un esquema manual. En particular, si el programa fue diseñado con el
recolector de basura en mente en ciertas circunstancias puede ser incluso más
eficiente que uno que hace manejo explícito de la memoria. Muchos recolectores
+.. _gc_intro_basics:
Conceptos básicos
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Los programas pueden hacer uso principalmente de 4 áreas de memoria:
-Registros:
+Registros
Se trata de la memoria más básica de una computadora. Es el área de memoria
en la que puede operar realmente el procesador, es extremadamente escasa
y generalmente su uso es administrado por el lenguaje de programación (o
realizando tareas de muy bajo nivel, un programador nunca manipula los
registros explícitamente.
-Área de memoria estática:
+Área de memoria estática
Es la forma de memoria más simple que un programador utiliza
explícitamente. En general las variables globales se almacenan en este
área, que es parte inherente del programa y está disponible durante toda su
compilación**. Los primeros lenguajes de programación solo contaban con
este tipo de memoria (además de los registros del procesador).
-*Stack* (pila):
+*Stack* (pila)
Los primeros lenguajes de programación que hicieron uso de una pila
aparecieron en el año 1958 (Algol-58 y Atlas Autocode) y fueron los
primeros en introducir estructura de bloques, almacenando las variables
utilizar recursividad y tener un esquema simple de memoria dinámica. Sin
embargo este esquema es muy limitado porque el orden de reserva
y liberación de memoria tiene que estar bien establecido. Una celda
- [#gccelda]_ alocada antes que otra nunca puede ser liberada antes que
+ [#gccelda]_ asignada antes que otra nunca puede ser liberada antes que
aquella.
.. [#gccelda] En general en la literatura se nombra a una porción de
- memoria alocada individualmente *celda*, *nodo* u *objeto*
+ memoria asignada individualmente *celda*, *nodo* u *objeto*
indistintamente. En este trabajo se utilizará la misma nomenclatura
(haciendo mención explícita cuando alguno de estos términos se refiera
a otra cosa, como al nodo de una lista o a un objeto en el sentido de
programación orientada a objetos).
-*Heap*:
+*Heap*
A diferencia del *stack*, el *heap* provee un área de memoria que puede ser
obtenida dinámicamente pero sin limitaciones de orden. Es el tipo de
memoria más flexible y por lo tanto el más complejo de administrar; razón
de memoria está almacenada en una celda *raíz* (parte del *root set*) o si
está almacenada en otra celda *viva* del *heap*.
-Expresado más formalmente, dada la relación :math:`M \to N`, donde :math:`M`
-es una celda del *heap* o parte del *root set* y :math:`N` es una celda del
-*heap*, definida como:
-
-.. math::
-
- M \to N \Longleftrightarrow M \text{ almacena un puntero a } N
-
-El conjunto de celdas vivas (o *live set*) queda determinado por:
-
-.. math::
-
- vivas = \left\lbrace N \in Celdas \big/
- ( \exists r \in Raices / r \to N ) \vee (\exists M \in vivas / M \to N )
- \right\rbrace
-
Cabe aclarar que esta es una definición conceptual, asumiendo que el programa
siempre limpia una dirección de memoria almacenada en el *root set* o una
celda del *heap* cuando la celda a la que apunta no va a ser utilizada
-nuevamente. Esto no es siempre cierto y los falsos positivos que esto produce
-se conoce como un tipo de pérdida de memoria (que es posible incluso al
-utilizar un recolector de basura) llamada pérdida de memoria *lógica*. Esto
+nuevamente. Esto no es siempre cierto y los *falsos positivos* que esto
+produce se conoce como un tipo de pérdida de memoria (que es posible incluso
+al utilizar un recolector de basura) llamada pérdida de memoria *lógica*. Esto
puede no ser evitable (incluso cuando el programador no cometa errores) en
lenguajes de programación que requieran un recolector de basura conservativo.
Por último, siendo que el recolector de basura es parte del programa de forma
-indirecta, es común ver en la literatura que se direfencia entre
-2 partes del programa, el recolector de basura y el programa en sí. Dado que
- para el recolector de basura, lo único que interesa conocer del programa en
- sí son los cambios al grafo de conectividad de las celdas, normalmente se lo
- llama *mutator* (mutador).
+indirecta, es común ver en la literatura que se diferencia entre dos partes
+del programa, el recolector de basura y el programa en sí. A la primera se la
+suele denominar simplemente *recolector* y a la segunda *mutator*, dado que es
+la única que modifica (o *muta*) el grafo de conectividad.
Más formalmente, Definimos:
-*Camino*:
- secuencia de vértices tal que cada uno de los vértices tiene una arista al
- próximo vértice en la secuencia. Todo camino finito tiene un *vértice
- inicial* y un *vértice final* (llamados en conjunto *vértices terminales*).
- Cualquier vértice no terminal es denominado *vértice interior*.
+*Camino*
+ Es una secuencia de vértices tal que cada uno de los vértices tiene una
+ arista al próximo vértice en la secuencia. Todo camino finito tiene un
+ *vértice inicial* y un *vértice final* (llamados en conjunto *vértices
+ terminales*). Cualquier vértice no terminal es denominado *vértice
+ interior*.
.. math::
\exists (v_i \to v_{i+1}) \in A
\right\rbrace
-*Conexión*:
- decimos que :math:`M` está *conectado* a :math:`N` si y sólo si existe un
+ Un camino cuyos *vértices terminales* coinciden, es decir :math:`v_1
+ = v_N`, es denominado **Ciclo**. Cabe notar que los *vértices terminales*
+ de un ciclo son completamente arbitrarios, ya que cualquier *vértice
+ interior* puede ser un *vértice terminal*.
+
+*Conexión*
+ Decimos que :math:`M` está *conectado* a :math:`N` si y sólo si existe un
camino de :math:`M` a :math:`N`.
.. math::
M \mapsto N \Longleftrightarrow \exists \underset{M \to N}{C} \in G
-*Live set*:
- el conjunto de celdas *vivas* está dado por todos los vértices (:math:`v`)
- del grafo para los cuales existe una raíz en el *root set* que esté
- conectada a él.
+*Live set*
+ Es el conjunto de celdas *vivas* está dado por todos los vértices
+ (:math:`v`) del grafo para los cuales existe una raíz en el *root set* que
+ esté conectada a él.
.. math::
\left( \exists r \in Root \thickspace set \big/ r \mapsto v \right)
\right\rbrace
-*Basura*:
- la basura, o celdas *muertas*, quedan determinadas entonces por todas las
+*Basura*
+ La basura, o celdas *muertas*, quedan determinadas entonces por todas las
celdas del *heap* que no son parte del *live set*.
.. math::
Basura = V - Live \thickspace set
-Esto es, efectivamente, una partición del *heap* (ver figura
+El *Live set* y la *Basura* conforman una partición del *heap* (ver figura
:vref:`fig:gc-heap-parts`).
-.. fig:: fig:gc-heap-parts
+.. flt:: fig:gc-heap-parts
- Distintas partes de la memoria *heap*.
+ Distintas partes de la memoria *heap*
Distintas partes de la memoria, incluyendo relación entre *basura*, *live
set*, *heap* y *root set*.
Al proceso de visitar los vértices *conectados* desde el *root set* se lo
denomina *marcado*, *fase de marcado* o *mark phase* en inglés, debido a que
-es necesario marcar los vértices para evitar visitar 2 veces el mismo nodo en
-casos de que el grafo contenga ciclos [#gccycle]_. De forma similar a la
-búsqueda, que puede realizarse *primero a lo ancho* (*breadth-first*)
-o *primero a lo alto* (*depth-first*) del grafo, el marcado de un grafo
-también puede realizarse de ambas maneras. Cada una podrá o no tener efectos
-en la eficiencia, en particular dependiendo de la aplicación puede convenir
-uno u otro método para lograr una mejor localidad de referencia.
-
-.. [#gccycle] Un ciclo es un camino donde el *vértice inicial* es el mismo
- que el *vértice final*. Por lo tanto, los *vértices terminales* son
- completamente arbitrarios, ya que cualquier *vértice interior* puede ser un
- *vértice terminal*.
-
-Un algoritmo simple (recursivo) de marcado *primero a lo alto* puede ser el
+es necesario marcar los vértices para evitar visitar dos veces el mismo nodo
+en casos en los que el grafo contenga ciclos. De forma similar a la búsqueda,
+que puede realizarse *primero a lo ancho* (*breadth-first*) o *primero a lo
+alto* (*depth-first*) del grafo, el marcado de un grafo también puede
+realizarse de ambas maneras. Cada una podrá o no tener efectos en el
+rendimiento, en particular dependiendo de la aplicación puede convenir uno
+u otro método para lograr una mejor localidad de referencia.
+
+Un algoritmo simple (recursivo) de marcado *primero a lo alto* puede ser el
siguiente (asumiendo que partimos con todos los vértices sin marcar)
[#gcpseudo]_::
function mark(v) is
if not v.marked
v.marked = true
- for (src, dst) in v.edges
+ foreach (src, dst) in v.edges
mark(dst)
function mark_phase() is
*basura* (en blanco).
-.. fig:: fig:gc-mark-1
+.. flt:: fig:gc-mark-1
- Ejemplo de marcado del grafo de conectividad (parte 1).
+ Ejemplo de marcado del grafo de conectividad (parte 1)
- .. subfig::
+ .. subflt::
Se comienza a marcar el grafo por la raíz r0.
}
- .. subfig::
+ .. subflt::
Luego de marcar el nodo ``h1``, se procede al ``h2``.
}
- .. subfig::
+ .. subflt::
Luego sigue el nodo h5.
}
-.. fig:: fig:gc-mark-2
+.. flt:: fig:gc-mark-2
- Ejemplo de marcado del grafo de conectividad (parte 2).
+ Ejemplo de marcado del grafo de conectividad (parte 2)
- .. subfig::
+ .. subflt::
El nodo h5 tiene una arista al h1, pero el h1 ya fue visitado, por lo
tanto no se visita nuevamente.
}
- .. subfig::
+ .. subflt::
Se concluye el marcado del sub-grafo al que conecta r0, se procede
a marcar el sub-grafo al que conecta r1, marcando al nodo h6.
}
- .. subfig::
+ .. subflt::
El nodo h6 tiene una arista al h2, pero éste ya fue marcado por lo
que no se vuelve a visitar. No hay más raíces, se finaliza el marcado
color, gris generalmente, indica que una celda debe ser visitada. Esto permite
algoritmos :ref:`concurrentes <gc_concurrent>` e :ref:`incrementales
<gc_inc>`, además de otro tipo de optimizaciones. Entonces, lo que plantea
-esta abtracción es una nueva partición del heap al momento de marcar, esta vez
-son 3 porciones: blanca, gris y negra.
+esta abstracción es una nueva partición del heap al momento de marcar, esta
+vez son tres porciones: blanca, gris y negra.
Al principio todas las celdas se pintan de blanco, excepto el *root set* que
-se punta de gris. Luego se van obteniendo celdas del conjunto de las grises
+se pinta de gris. Luego se van obteniendo celdas del conjunto de las grises
y se las pinta de negro, pintando sus hijas directas de gris.
Una vez que no hay más celdas grises, tenemos la garantía de que las celdas
negras serán el *live set* y las celdas blancas *basura*. Esto se debe a que
siempre se mantiene esta invariante: **ninguna celda negra apunta directamente
-a una celda blanca**. Las celdas blancas siempre son apuntadas por celdas
-blancas o grises. Entonces, siempre que el conjunto de celdas grises sea
-vacío, no habrán celdas negras conectadas a blancas, siendo las celdas blancas
-*basura*.
+a una celda blanca** (considerando como atómica la operación de pintar una
+celda de negro y a sus hijas directas de gris). Las celdas blancas siempre son
+apuntadas por celdas blancas o grises. Entonces, siempre que el conjunto de
+celdas grises sea vacío, no habrán celdas negras conectadas a blancas, siendo
+las celdas blancas *basura*.
El algoritmo básico para marcar con tres colores es el siguiente (asumiendo
que todas las celdas parten pintadas de blanco, es decir, el conjunto blanco
while not gray_set.empty()
v = gray_set.pop()
black_set.add(v)
- for (src, dst) in v.edges
- if v in white_set
- white_set.remove(v)
- gray_set.add(v)
+ foreach (src, dst) in v.edges
+ if dst in white_set
+ white_set.remove(dst)
+ gray_set.add(dst)
-Es simple notar que este algoritmo es naturalmente no recursivo, lo que de por
-sí ya presenta una ventaja sobre el marcado *bicolor*.
+Si bien este algoritmo no es recursivo, tiene un requerimiento de espacio
+:math:`O(\lvert Live \thickspace set \rvert)`. Un ejemplo donde se aprecia
+esto a simple vista es cuando el *Live set* resulta una lista simplemente
+enlazada, en cuyo caso el *gray_set* deberá almacenar todos los nodos del
+*Live set*.
Servicios utilizados por el recolector son los siguientes:
-:math:`alloc() \to cell`:
- obtiene una nueva celda de memoria. El mecanismo por el cual se obtiene la
+:math:`alloc() \to cell`
+ Obtiene una nueva celda de memoria. El mecanismo por el cual se obtiene la
celda es indistinto para esta sección, puede ser de una lista libre, puede
ser de un administrador de memoria de más bajo nivel provisto por el
sistema operativo o la biblioteca estándar de C (``malloc()``), etc. Cómo
contrario) que las celdas son de tamaño fijo. Esta restricción normalmente
puede ser fácilmente relajada (en los recolectores que la tienen).
-:math:`free(cell)`:
- libera una celda que ya no va a ser utilizada. La celda liberada debe haber
+:math:`free(cell)`
+ Libera una celda que ya no va a ser utilizada. La celda liberada debe haber
sido obtenida mediante ``alloc()``.
Y los servicios básicos proporcionados por el recolector son los siguientes:
-:math:`new() \to cell`:
- obtiene una celda de memoria para ser utilizada por el programa.
+:math:`new() \to cell`
+ Obtiene una celda de memoria para ser utilizada por el programa.
-:math:`update(ref, cell)`:
- notifica al recolector que la referencia :math:`ref` ahora apunta
+:math:`update(ref, cell)`
+ Notifica al recolector que la referencia :math:`ref` ahora apunta
a :math:`cell`. Visto más formalmente, sería análogo a decir que hubo un
cambio en la conectividad del grafo: la arista :math:`src \to old` cambia
por :math:`src \to new` (donde :math:`src` es la celda que contiene la
:math:`cell` es ``null``, sería análogo a informar que se elimina la arista
:math:`src \to old`.
-:math:`del(cell)`:
- este servicio, según el algoritmo, puede ser utilizado para informar un
+:math:`del(cell)`
+ Este servicio, según el algoritmo, puede ser utilizado para informar un
cambio en la conectividad del grafo, la eliminación de una arista (análogo
a :math:`update(ref, null)` pero sin proporcionar información sobre la
arista a eliminar). Esto es generalmente útil solo en :ref:`conteo de
referencias <gc_rc>`. Para otros recolectores puede significar que el
usuario asegura que no hay más referencias a esta celda, es decir, análogo
a eliminar el conjunto de aristas :math:`\big\lbrace (v, w) \in A , v \in
- Live \thickspace set , w \in Live \thickspace set \big/ w = cell`.
+ Live \thickspace set , w \in Live \thickspace set \big/ w = cell
+ \big\rbrace`.
-:math:`collect()`:
- indica al recolector que debe hacer un análisis del grafo de conectividad
- en busca de *basura*. Generalmente este servicio es invocado por el propio
- recolector cuando no hay más celdas reciclables.
+:math:`collect()`
+ Este servicio indica al recolector que debe hacer un análisis del grafo de
+ conectividad en busca de *basura*. Generalmente este servicio es invocado
+ por el propio recolector cuando no hay más celdas reciclables.
No todos los servicios son implementados por todos los recolectores, pero son
lo suficientemente comunes como para describirlos de forma general en esta
Algoritmos clásicos
----------------------------------------------------------------------------
-En la literatura se encuentran normalmente referencias a 3 algoritmos
+En la literatura se encuentran normalmente referencias a tres algoritmos
clásicos, que son utilizados generalmente como bloques básicos para construir
recolectores más complejos. Se presentan las versiones históricas más simples
a fin de facilitar la comprensión conceptual.
El conteo de referencias tiene, sin embargo, un problema fundamental: **falla
con estructuras cíclicas**. Esto significa que siempre que haya un ciclo en el
-grafo de conectividad, hay una pérdida de memoria potencial en el programa. Un
-ciclo es un camino :math:`\underset{v \to v}{C}`, es decir, el *vértice
-inicial* es el mismo que el *vértice final*.
+grafo de conectividad, hay una pérdida de memoria potencial en el programa.
Cuando esto sucede, las celdas que participan del ciclo tienen siempre su
-contador mayor que 0, sin embargo puede no haber ningún elemento del *root
-set* que apunte a una celda dentro del ciclo, por lo tanto el ciclo es
-*basura* (al igual que cualquier otra celda que sea referenciada por el ciclo
-pero que no tenga otras referencias externas) y sin embargo los contadores no
-son 0. Los ciclos, por lo tanto, *rompen* la invariante del conteo de
-referencia.
+contador mayor que 0, sin embargo puede suceder que ningún elemento del *root
+set* apunte a una celda dentro del ciclo, por lo tanto el ciclo es *basura*
+(al igual que cualquier otra celda para la cual hayan referencias desde el
+ciclo pero que no tenga otras referencias externas) y sin embargo los
+contadores no son 0. Los ciclos, por lo tanto, violan la invariante del conteo
+de referencia.
Hay formas de solucionar esto, pero siempre recaen en un esquema que va por
fuera del conteo de referencias puro. En general los métodos para solucionar
-esto son variados y van desde realizar un marcado del subgrafo para detectar
-nodos hasta tener otro recolector completo de *emergencia*, pasando por tratar
-los ciclos como un todo contar las referencias al ciclo completo en vez de
-a cada celda en particular.
+esto son variados y van desde realizar un marcado del sub-grafo para detectar
+ciclos y liberarlos hasta tener otro recolector completo de *emergencia*;
+pasando por tratar los ciclos como un todo para contar las referencias al
+ciclo completo en vez de a cada celda en particular.
Incluso con este problema, el conteo de referencia sin ningún tipo de solución
en cuanto a la detección y recolección de ciclos fue utilizado en muchos
lenguajes de programación sin que su necesidad sea tan evidente. Por ejemplo
Python_ agregó recolección de ciclos en la versión 2.0 [NAS00]_ (liberada en
octubre de 2000) y PHP_ recién agrega detección de ciclos en la versión 5.3
-(todavía no liberada al momento de escribir este documento) [PHP081]_.
+[PHP530]_.
.. _gc_rc_example:
del algoritmo. Por simplicidad se asumen celdas de tamaño fijo con dos
punteros, ``left`` (``l``) y ``right`` (``r``) y se muestra el contador de
referencias abajo del nombre de cada celda. Se parte con una pequeña
-estructura ya construída y se muestra como opera el algoritmo al eliminar
+estructura ya construida y se muestra como opera el algoritmo al eliminar
o cambiar una referencia (cambios en la conectividad del grafo). En un
comienzo todas las celdas son accesibles desde el *root set* por lo tanto son
todas parte del *live set*.
*live set* ya que sus contadores siguen siendo mayores a 0 (ver figura
:vref:`fig:gc-rc-rm-2`).
-.. fig:: fig:gc-rc-rm-1
+.. flt:: fig:gc-rc-rm-1
- Ejemplo de conteo de referencias: eliminación de una referencia (parte 1).
+ Ejemplo de conteo de referencias: eliminación de una referencia (parte 1)
Eliminación de la referencia ``r0`` :math:`\to` ``h1`` (parte 1).
- .. subfig::
+ .. subflt::
Estado inicial del grafo de conectividad.
}
- .. subfig::
+ .. subflt::
Al ejecutarse ``update(r0, null)``, se comienza por visitar la celda
``h1``.
}
- .. subfig::
+ .. subflt::
Se decrementa el contador de ``h1`` quedando en 0 (pasa a ser *basura*).
Se elimina primero ``h1.l`` y luego ``h1.r``.
}
-.. fig:: fig:gc-rc-rm-2
+.. flt:: fig:gc-rc-rm-2
:padding: 0.5
- Ejemplo de conteo de referencias: eliminación de una referencia (parte 2).
+ Ejemplo de conteo de referencias: eliminación de una referencia (parte 2)
Eliminación de la referencia ``r0`` :math:`\to` ``h1`` (parte 2).
- .. subfig::
+ .. subflt::
Se decrementa el contador de ``h2`` pero no queda en 0 (permanece en el
*live set*).
}
- .. subfig::
+ .. subflt::
El contador de ``h3`` tampoco queda en 0, sigue en el *live set*.
contador de ``h2`` que queda en 0, transformándose en *basura* (ver figura
:vref:`fig:gc-rc-up-1`).
-.. fig:: fig:gc-rc-up-1
+.. flt:: fig:gc-rc-up-1
- Ejemplo de conteo de referencias: actualización de una referencia (parte 1).
+ Ejemplo de conteo de referencias: actualización de una referencia (parte 1)
- Cambio en la referencia ``h2.l`` :math:`\to` ``h2`` a ``h2.l`` :math:`\to`
+ Cambio en la referencia ``h3.l`` :math:`\to` ``h2`` a ``h3.l`` :math:`\to`
``h5`` (parte 1).
- .. subfig::
+ .. subflt::
Comienza ``update(h3.l, h5)``, se incrementa el contador de ``h5``.
}
- .. subfig::
+ .. subflt::
- Luego se procede a visitar las hijas de ``h3``, comenzando por ``h2``.
+ Luego se procede a visitar la antigua referencia de ``h3.l`` (``h2``).
.. digraph:: g4_2
}
- .. subfig::
+ .. subflt::
Se decrementa el contador de ``h2`` y queda en 0 (pasa a ser *basura*).
Se eliminan las referencias a las hijas.
};
h1 [ label = "h1\n0|<l> l|<r> r" ];
- h2 [ label = "h2\n1|<l> l|<r> r" ];
+ h2 [ label = "h2\n0|<l> l|<r> r" ];
h3 [ label = "h3\n2|<l> l\n*|<r> r" ];
h4 [ label = "h4\n1|<l> l|<r> r" ];
h5 [ label = "h5\n2|<l> l|<r> r" ];
de actualizar la referencia ``h3.l`` para que apunte a ``h5`` (ver figura
:vref:`fig:gc-rc-up-2`).
-.. fig:: fig:gc-rc-up-2
+.. flt:: fig:gc-rc-up-2
- Ejemplo de conteo de referencias: actualización de una referencia (parte 2).
+ Ejemplo de conteo de referencias: actualización de una referencia (parte 2)
- Cambio en la referencia ``h2.l`` :math:`\to` ``h2`` a ``h2.l`` :math:`\to`
+ Cambio en la referencia ``h3.l`` :math:`\to` ``h2`` a ``h3.l`` :math:`\to`
``h5`` (parte 2).
- .. subfig::
+ .. subflt::
Se decrementa el contador de ``h4`` quedando en 0, pasa a ser *basura*.
Se continúa con ``h5``.
};
h1 [ label = "h1\n0|<l> l|<r> r" ];
- h2 [ label = "h2\n1|<l> l|<r> r" ];
+ h2 [ label = "h2\n0|<l> l|<r> r" ];
h3 [ label = "h3\n2|<l> l\n*|<r> r" ];
h4 [ label = "h4\n0|<l> l|<r> r" ];
h5 [ label = "h5\n2|<l> l|<r> r" ];
}
- .. subfig::
+ .. subflt::
Se decrementa el contador de ``h5`` pero sigue siendo mayor que 0.
};
h1 [ label = "h1\n0|<l> l|<r> r" ];
- h2 [ label = "h2\n1|<l> l|<r> r" ];
+ h2 [ label = "h2\n0|<l> l|<r> r" ];
h3 [ label = "h3\n2|<l> l\n*|<r> r" ];
h4 [ label = "h4\n0|<l> l|<r> r" ];
h5 [ label = "h5\n1|<l> l|<r> r" ];
}
- .. subfig::
+ .. subflt::
Se termina por actualizar la referencia de ``h3.l`` para que apunte
a ``h5``.
pueden ser recicladas y su memoria es perdida (ver figura
:vref:`fig:gc-rc-cycle`).
-.. fig:: fig:gc-rc-cycle
+.. flt:: fig:gc-rc-cycle
:padding: 0.5
- Ejemplo de conteo de referencias: pérdida de memoria debido a un ciclo.
+ Ejemplo de conteo de referencias: pérdida de memoria debido a un ciclo
Eliminación de la referencia ``r1`` :math:`\to` ``h3`` (pérdida de memoria
debido a un ciclo).
- .. subfig::
+ .. subflt::
El ejecutarse ``update(r1, null)`` se visita la celda ``h3``.
}
- .. subfig::
+ .. subflt::
Se decrementa el contador de ``h3`` pero sigue siendo mayor que 0 por el
ciclo.
Este algoritmo consiste en hacer una partición del *heap* en 2 mitades
o *semi-espacios*, llamados usualmente *Fromspace* y *Tospace*. El primero se
-utiliza para alocar nuevas celdas de forma lineal, asumiendo un *heap*
+utiliza para asignar nuevas celdas de forma lineal, asumiendo un *heap*
contiguo, incrementando un puntero (ver figura :vref:`fig:gc-copy`). Esto se
conoce como *pointer bump allocation* y es, probablemente, la forma más
-eficiente de alocar memoria (tan eficiente como alocar memoria en el *stack*).
+eficiente de asignar memoria (tan eficiente como asignar memoria en el
+*stack*). Esto permite además evitar el problema de la *fragmentación* de
+memoria [#gcfrag]_ que normalmente afectan a los otros algoritmos clásicos (o
+sus *low level allocators*).
-.. fig:: fig:gc-copy
+.. [#gcfrag] La *fragmentación* de memoria sucede cuando se asignan objetos
+ de distintos tamaños y luego libera alguno intermedio, produciendo
+ *huecos*. Estos *huecos* quedan inutilizables hasta que se quiera
+ asignar un nuevo objeto de tamaño igual al *hueco* (o menor). Si esto no
+ sucede y se acumulan muchos *huecos* se dice que la memoria está
+ *fragmentada*.
- Estructura del *heap* de un recolector con copia de semi-espacios.
+.. flt:: fig:gc-copy
+
+ Estructura del *heap* de un recolector con copia de semi-espacios
.. aafig::
- :aspect: 0.7
- :scale: 1.4
+ :aspect: 70
+ :scale: 115
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
espacio en el *Fromspace*; en ese momento comienza el proceso de recolección
de basura que consiste en recorrer el grafo de conectividad, copiando las
celdas *vivas* del *Fromspace* al *Tospace* de manera contigua, como si
-estuvieran alocando por primera vez. Como la posición en memoria de las celdas
-cambia al ser movidas, es necesario actualizar la dirección de memoria de
-todas las celdas *vivas*. Para esto se almacena una dirección de memoria de
-redirección, *forwarding address*, en las celdas que mueven. La *forwarding
+estuvieran asignando por primera vez. Como la posición en memoria de las
+celdas cambia al ser movidas, es necesario actualizar la dirección de memoria
+de todas las celdas *vivas*. Para esto se almacena una dirección de memoria de
+re-dirección, *forwarding address*, en las celdas que mueven. La *forwarding
address* sirve a su vez de marca, para no recorrer una celda dos veces (como
se explica en :ref:`gc_intro_mark`). Cuando se encuentra una celda que ya fue
movida, simplemente se actualiza la referencia por la cual se llegó a esa
A continuación se presenta una implementación sencilla de los servicios
provistos por este tipo de recolectores. Cabe destacar que este tipo de
recolectores deben estar íntimamente relacionados con el *low level
-allocator*, ya que la organización del *heap* y la forma de alocar memoria es
+allocator*, ya que la organización del *heap* y la forma de asignar memoria es
parte fundamental de este algoritmo. Se asume que ya hay dos áreas de memoria
del mismo tamaño destinadas al *Fromspace* y *Tospace*, y la existencia de
-4 variables: ``fromspace`` (que apunta a la base del *Fromspace*), ``tospace``
-(que apunta a la base del *Tospace*), ``spacesize`` (que contiene el tamaño de
-un semi-espacio) y ``free`` (que apunta al lugar del *Fromspace* donde
-comienza la memoria libre). También vale aclarar que este algoritmo soporta
-inherentemente celdas de tamaño variable, por lo que los servicios ``alloc()``
-y ``new()`` [#gccopynew]_ reciben como parámetro el tamaño de la celda
-a alocar::
+4 variables globales: ``fromspace`` (que apunta a la base del *Fromspace*),
+``tospace`` (que apunta a la base del *Tospace*), ``spacesize`` (que contiene
+el tamaño de un semi-espacio) y ``free`` (que apunta al lugar del *Fromspace*
+donde comienza la memoria libre). También vale aclarar que este algoritmo
+soporta inherentemente celdas de tamaño variable, por lo que los servicios
+``alloc()`` y ``new()`` [#gccopynew]_ reciben como parámetro el tamaño de la
+celda a asignar::
function alloc(size) is
if free + size > fromspace + spacesize
function copy(cell) is
if cell.forwarding_address is null
cell.forwarding_address = free
+ cell.copy_to(free)
free = free + cell.size
foreach child in cell
child = copy(child)
<gc_concurrent>`. Las diferencias con los esquemas vistos hasta ahora son
evidentes. La principal ventaja sobre el marcado y barrido (que requiere una
pasada sobre el *live set*, el marcado, y otra sobre el *heap* entero, el
-barrido) es que este método require una sola pasada y sobre las celdas vivas
+barrido) es que este método requiere una sola pasada y sobre las celdas vivas
del *heap* solamente. La principal desventaja es copia memoria, lo que puede
ser particularmente costoso, además de requerir, como mínimo, el doble de
memoria de lo que el *mutator* realmente necesita. Esto puede traer en
*forwarding address* a la nueva ubicación (ver figura
:vref:`fig:gc-copy-ex-1`).
-.. fig:: fig:gc-copy-ex-1
+.. flt:: fig:gc-copy-ex-1
- Ejemplo de recolección con copia de semi-espacios (parte 1).
+ Ejemplo de recolección con copia de semi-espacios (parte 1)
- .. subfig::
+ .. subflt::
Estructura inicial del *heap*. El *Fromspace* está complete y se inicial
la recolección.
.. aafig::
- :scale: 1.25
+--------------------------------------------------+
| "Fromspace" |
| "Tospace" |
+--------------------------------------------------+
- .. subfig::
+ .. subflt::
Se sigue la referencia del *root set*, copiando ``h3`` al *Tospace*
y dejando una *forwarding address*.
.. aafig::
- :scale: 1.25
+--------------------------------------------------+
| "Fromspace" |
ubicación de ``h2`` pero no se vuelve a copiar la celda (ver figura
:vref:`fig:gc-copy-ex-2`).
-.. fig:: fig:gc-copy-ex-2
+.. flt:: fig:gc-copy-ex-2
- Ejemplo de recolección con copia de semi-espacios (parte 2).
+ Ejemplo de recolección con copia de semi-espacios (parte 2)
- .. subfig::
+ .. subflt::
Se sigue :math:`h3 \to h2`, copiando ``h2`` al *Tospace* y dejando una
*forwarding address*.
.. aafig::
- :scale: 1.25
+--------------------------------------------------+
| "Fromspace" |
| "Tospace" |
+--------------------------------------------------+
- .. subfig::
+ .. subflt::
Se sigue :math:`h2 \to h1`, copiando ``h1``. Luego :math:`h1 \to h2`
pero ``h2`` no se copia, sólo se actualiza la referencia con la
*forwarding address*.
.. aafig::
- :scale: 1.25
+--------------------------------------------------+
| "Fromspace" |
nueva ubicación de ``h3``, como se muestra en la figura
:vref:`fig:gc-copy-ex-3`.
-.. fig:: fig:gc-copy-ex-3
+.. flt:: fig:gc-copy-ex-3
- Ejemplo de recolección con copia de semi-espacios (parte 3).
+ Ejemplo de recolección con copia de semi-espacios (parte 3)
- .. subfig::
+ .. subflt::
Se sigue :math:`h1 \to h4` copiando `h4`` al *Tospace* y dejando una
*forwarding address*.
.. aafig::
- :scale: 1.25
+--------------------------------------------------+
| "Fromspace" |
| "Tospace" \------/ |
+--------------------------------------------------+
- .. subfig::
+ .. subflt::
Se finaliza la recolección, se intercambian los roles de los
semi-espacios y se actualiza la referencia del *root set*.
.. aafig::
- :scale: 1.25
+--------------------------------------------------+
| "Tospace" |
algunos :ref:`recolectores incrementales <gc_inc>` que a veces necesitan
instrumentar el *mutator* pero no para mantener el estado del grafo de
conectividad completo). La recolección se dispara usualmente cuando el
-*mutator* requiere alocar memoria pero no hay más memoria libre conocida
+*mutator* requiere asignar memoria pero no hay más memoria libre conocida
disponible y el recolector se encarga de generar la información de
conectividad desde cero para determinar qué celdas son *basura*.
-
-Esta es la madre de toda clasificación, también conocidos como :ref:`conteo de
-referencias <gc_rc>` (directa) y *traicing garbage collection* (indirecta).
Prácticamente todos los recolectores menos el :ref:`conteo de referencias
-<gc_rc>` están dentro de esta última categoría (como por ejemplo, el
-:ref:`marcado y barrido <gc_mark_sweep>` y :ref:`copia de semi-espacio
-<gc_copy>`).
+<gc_rc>` están dentro de esta categoría (como por ejemplo, el :ref:`marcado
+y barrido <gc_mark_sweep>` y :ref:`copia de semi-espacio <gc_copy>`).
Otros ejemplos de recolectores modernos *directos* son el recolector de basura
de Python_ [NAS00]_ y [LINS05]_ (aunque ambos tiene un algoritmo *indirecto*
básica es el :ref:`conteo de referencias <gc_rc>`. Otros recolectores pueden
hacerse incrementales de diversas maneras, pero en general consta de hacer
parte del trabajo de escanear el grafo de conectividad cada vez que el
-*mutator* aloca memoria. En general para hacer esto es también necesario
+*mutator* asigna memoria. En general para hacer esto es también necesario
instrumentar al *mutator* de forma tal que informe al recolector cada vez que
cambia el grafo de conectividad, para que éste pueda marcar al sub-grafo
afectado por el cambio como *desactualizado* y así re-escanearlo nuevamente en
cuando el *mutator* cambia una referencia, se marca *gris* la celda que la
contiene, de modo que el recolector vuelva a visitarla.
-En general la eficiencia de los recolectores incrementales disminuye
+En general el rendimiento de los recolectores incrementales disminuye
considerablemente cuando el *mutator* actualiza muy seguido el grafo de
conectividad, porque debe re-escanear sub-grafos que ya había escaneado una
y otra vez. A esto se debe también que en general el tiempo de procesamiento
disponibles para realizar la recolección (ver figura
:vref:`fig:gc-concurrent`).
-.. fig:: fig:gc-concurrent
+.. flt:: fig:gc-concurrent
Distintos tipos de recolectores según el comportamiento en ambientes
- multi-hilo.
+ multi-hilo
- .. subfig::
+ .. subflt::
*Stop-the-world*.
.. aafig::
- :aspect: 0.7
+ :scale: 110
+ :aspect: 70
___________________________________________________________________
| |
| HH Mutator ZZ Inactivo XX Recolector |
|___________________________________________________________________|
- .. subfig::
+ .. subflt::
Paralelo.
.. aafig::
- :aspect: 0.7
+ :scale: 110
+ :aspect: 70
___________________________________________________________________
| |
| HH Mutator ZZ Inactivo XX Recolector |
|___________________________________________________________________|
- .. subfig::
+ .. subflt::
Concurrente.
.. aafig::
- :aspect: 0.7
+ :scale: 110
+ :aspect: 70
___________________________________________________________________
| |
sido modificados, además de la sincronización necesaria entre *mutator*
y recolector.
-¿Cúal es la idea entonces de un recolector concurrente? Una vez más, al igual
+¿Cuál es la idea entonces de un recolector concurrente? Una vez más, al igual
que los recolectores incrementales, el principal objetivo es disminuir las
largas pausas provocadas por la recolección de basura. Sin embargo, este tipo
de algoritmos además permite hacer un mejor aprovechamiento de las
-arquitecturas *multi-core* [#gcmulticore]_ que cada vez se afirman más, ya que
-el *mutator* y el recolector pueden estar corriendo realmente en paralelo,
+arquitecturas *multi-core* [#gcmulticore]_ que cada vez son más comunes, ya
+que el *mutator* y el recolector pueden estar corriendo realmente en paralelo,
cada uno en un procesador distinto. Algunos recolectores van más allá
y permiten incluso paralelizar la recolección de basura en varios hilos
([HUEL98]_, [LINS05]_). Otros ejemplos de recolectores concurrentes (aunque no
desenlaza de la lista de libres. Por otro lado, cuando el recolector detecta
una celda *muerta*, la vuelve a enlazar en la lista de libres. Este es un
esquema simple pero con limitaciones, entre las principales, el costo de
-alocar puede ser alto si hay muchos tamaños distintos de celda y soportar
+asignar puede ser alto si hay muchos tamaños distintos de celda y soportar
tamaño de celda variable puede ser complejo o acarrear muchas otras
-ineficiencias. :ref:`gc_mark_sweep` en general usa este esquema, al igual que
-:ref:`gc_rc`.
+ineficiencias. El :ref:`marcado y barrido <gc_mark_sweep>` en general usa este
+esquema, al igual que el :ref:`conteo de referencias <gc_rc>`.
Otro forma de organizar el *heap* es utilizándolo como una especie de *stack*
-en el cual para alocar simplemente se incrementa un puntero. Este esquema es
+en el cual para asignar simplemente se incrementa un puntero. Este esquema es
simple y eficiente, si el recolector puede mover celdas (ver
-:ref:`gc_moving`); de otra manera alocar puede ser muy costoso si hay que
+:ref:`gc_moving`); de otra manera asignar puede ser muy costoso si hay que
buscar un *hueco* en el heap (es decir, deja de reducirse a incrementar un
-puntero). El clásico ejemplo de esta familia es :ref:`gc_copy`.
+puntero). El clásico ejemplo de esta familia es el algoritmo visto en
+:ref:`gc_copy`.
Sin embargo, entre estos dos extremos, hay todo tipo de híbridos. Existen
recolectores basados en *regiones*, que se encuentran en un punto intermedio.
Dentro de una región se utiliza un esquema de *pointer bump allocation* pero
las regiones en sí se administran como una lista de libres (como por ejemplo
[BLAC08]_). Otra variación (más común) de este esquema son los *two level
-allocators* que alocan páginas completas (similar a las regiones) y dentro de
-cada página se alocan las celdas. Ambas, páginas y celdas, se administran como
-listas de libres (ejemplos que utilizan este esquema son [BOEHWD]_ y el
+allocators* que asignan páginas completas (similar a las regiones) y dentro de
+cada página se asignan las celdas. Ambas, páginas y celdas, se administran
+como listas de libres (ejemplos que utilizan este esquema son [BOEHWD]_ y el
:ref:`recolector actual de D <dgc_actual>`).
celdas o no. En general el movimiento de celdas viene de la mano del esquema
de :ref:`pointer bump allocation <gc_free_list>`, ya que *compacta* todas las
celdas *vivas* al comienzo del *heap* luego de una recolección, permitiendo
-este esquema para alocar nuevas celdas, pero puede utilizarse en esquemas
+este esquema para asignar nuevas celdas, pero puede utilizarse en esquemas
híbridos como recolectores basados en *regiones* (por ejemplo [BLAC08]_).
Además los recolectores con movimiento de celdas deben ser :ref:`precisos
básico que mueve celdas, el **marcado y compactado**. Éste no tiene
2 semi-espacios, directamente mueve las celdas compactándolas al comienzo del
*heap*. El algoritmo es un poco más complejo que la :ref:`copia de
-semi-espacios <gc_copy>` pero suele poder proveer una mayor localidad de
-referencia y *desperdicia* un semi-espacio que está inutilizado salgo en el
-momento de la recolección. Por ejemplo para Mono_, que antes usaba un
-recolector conservativo sin movimiento ([BOEHWD]_) se está implementando un
-recolector de este tipo [MOLAWE]_ [MOLA06]_.
+semi-espacios <gc_copy>` pero suele proveer una mayor localidad de referencia
+y no *desperdicia* un semi-espacio que está inutilizado salvo en el momento de
+la recolección. Por ejemplo para Mono_, que antes usaba un recolector
+conservativo sin movimiento ([BOEHWD]_) se está implementando un recolector de
+este tipo [MOLAWE]_ [MOLA06]_.
.. _gc_conserv:
-Recolectores conservativos vs precisos
+Recolectores conservativos versus precisos
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Los recolectores *conservativos* son aquellos que tienen la capacidad de poder
que en realidad son *basura* simplemente porque hay algún dato que coincide
con la dirección de memoria en la que está almacenada esa celda *basura*
[#gcflasepos]_. Además los recolectores puramente conservativos no puede mover
-celdas (ver :ref:`gc_moving`), porque no pueden arriesgarse a actualizar los
-punteros por el riesgo que existe de que sean falsos positivos.
+celdas (ver :ref:`gc_moving`), dado que no pueden actualizar los supuestos
+punteros por la posibilidad de que sean *falsos positivos*.
.. [#gcflasepos] Esto es lo que se conoce como un *falso positivo*, algo que
aparenta ser un puntero pero en realidad no lo es.
alto nivel) en general disponen de recolectores precisos.
Hay casos donde se posee información de tipos para algunas celdas solamente,
-o más comunmente se posee información de tipos de celdas que se encuentran en
+o más comúnmente se posee información de tipos de celdas que se encuentran en
el *heap* pero no para el *stack* y registros (por ejemplo [MOLA06]_). En
estos casos se puede adoptar un esquema híbrido y tratar algunas referencias
de forma conservativa y otras de forma precisa, de manera de mitigar, aunque
`Boehm-Demers-Wiser`_ ([BOEH88]_, [BOEH91]_, [BOEH93]_, [BOEHWD]_) aunque
puede comportarse de forma semi-precisa si el usuario se encarga de darle la
información de tipos (en cuyo caso el recolector deja de ser transparente para
-el usuario). Otros ejemplos de recolectores con cierto grado de
-conservativismo son el :ref:`recolector actual de D <dgc_actual>` y [BLAC08]_.
+el usuario). Otros ejemplos de recolectores con cierto grado de precisión son
+el :ref:`recolector actual de D <dgc_actual>` y [BLAC08]_.
.. _gc_part:
-Recolección particionada
+Recolección por particiones / generacional
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Otra forma de reducir la cantidad de pausas y la cantidad de trabajo realizado
-por el recolector en general es particionando el *heap* de manera tal de
-recolectar solo las partes donde más probabilidad de encontrar *basura* haya.
+por el recolector en general es dividiendo el *heap* en particiones de manera
+tal de recolectar solo las partes donde más probabilidad de encontrar *basura*
+haya.
Entonces, si el recolector tiene algún mecanismo para identificar zonas de
alta concentración de *basura* puede hacer la recolección solo en ese área
-donde el trabajo va a ser mejor recompensado (ver :vref:`fig:gc-part`).
+donde el trabajo va a ser mejor recompensado (ver figura :vref:`fig:gc-part`).
-.. fig:: fig:gc-part
+.. flt:: fig:gc-part
- Concentración de basura en distintas particiones del *heap*.
+ Concentración de basura en distintas particiones del *heap*
.. aafig::
- :aspect: 0.7
+ :scale: 110
+ :aspect: 70
_______________________________________________________________________
| |
Sin embargo encontrar zonas de alta concentración no es trivial. La forma más
-divulgada de encontrar estas zonas es particionando el *heap* en un área
+divulgada de encontrar estas zonas es dividiendo el *heap* en una partición
utilizada para almacenar celdas *jóvenes* y otra para celdas *viejas*. Una
-celda *vieja* es aquella que ha *sobrevivido* una cantidad N de recolecciones,
-mientras que el resto se consideran *jóvenes* (las celdas *nacen* jóvenes).
-Los recolectores que utilizan este tipo de partición son ampliamente conocido
-como recolectores **generacionales**. La *hipótesis generacional* dice que el
-área de celdas jóvenes tiene una mayor probabilidad de ser un área de alta
-concentración de basura [JOLI96]_. Basandose en esto, los recolectores
-generacionales primero intentan recuperar espacio del área de celdas jóvenes
-y luego, de ser necesario, del área de celdas viejas. Es posible tener varias
-generaciones e ir subiendo de generación a generación a medida que es
-necesario. Sin embargo en general no se obtienen buenos resultados una vez que
-se superan las 3 particiones. La complejidad que trae este método es que para
-recolectar la generación joven es necesario tomar las referencias de la
-generación vieja a la joven como parte del *root set* (de otra forma podrían
-tomarse celdas como *basura* que todavía son utilizadas por las celdas
-viejas). Revisar toda la generación vieja no es una opción porque sería
-prácticamente lo mismo que realizar una recolección del *heap* completo. La
-solución está entonces, una vez más, en instrumentar el *mutator* para que
+celda *vieja* es aquella que ha *sobrevivido* una cantidad *N* de
+recolecciones, mientras que el resto se consideran *jóvenes* (las celdas
+*nacen* jóvenes). Los recolectores que utilizan este tipo de partición son
+ampliamente conocido como recolectores **generacionales**. La *hipótesis
+generacional* dice que el área de celdas jóvenes tiene una mayor probabilidad
+de ser un área de alta concentración de basura [JOLI96]_. Basándose en esto,
+los recolectores generacionales primero intentan recuperar espacio del área de
+celdas jóvenes y luego, de ser necesario, del área de celdas viejas. Es
+posible tener varias generaciones e ir subiendo de generación a generación
+a medida que es necesario. Sin embargo en general no se obtienen buenos
+resultados una vez que se superan las 3 particiones. La complejidad que trae
+este método es que para recolectar la generación joven es necesario tomar las
+referencias de la generación vieja a la joven como parte del *root set* (de
+otra forma podrían tomarse celdas como *basura* que todavía son utilizadas por
+las celdas viejas). Revisar toda la generación vieja no es una opción porque
+sería prácticamente lo mismo que realizar una recolección del *heap* completo.
+La solución está entonces, una vez más, en instrumentar el *mutator* para que
avise al recolector cuando cambia una referencia de la generación vieja a la
-joven (no es necesario monitorear las referencias en sentido inverso ya que
+joven (no es necesario vigilar las referencias en sentido inverso ya que
cuando se recolecta la generación vieja se hace una recolección del *heap*
completo).
-Sin embargo, a pesar de ser este el esquema más difundido para particionar el
+Sin embargo, a pesar de ser este el esquema más difundido para dividir el
*heap* y realizar una recolección parcial sobre un área de alta concentración
-de basura no es la única. Otros recolectores proponen hacer un análisis
+de basura, no es la única. Otros recolectores proponen hacer un análisis
estático del código revisando la conectividad entre los objetos según sus
-tipos (esto es posible solo en lenguajes con tipado estático), de manera tal
+tipos (esto es posible solo en lenguajes con *tipado* estático), de manera tal
de separar en distintas áreas grupos de tipos que no pueden tener referencias
-entre sí [HIRZ03]_. Este análisis hace que sea inecesario instrumentar el
+entre sí [HIRZ03]_. Este análisis hace que sea innecesario instrumentar el
*mutator* para reportar al recolector cambios de referencias
inter-particiones, sencillamente porque queda demostrado que no existe dicho
-tipo de referencias. Esto quita una de las principale ineficiencias
+tipo de referencias. Esto quita una de las principales ineficiencias
y complejidades del esquema generacional.
.. include:: links.rst
-.. vim: set ts=3 sts=3 sw=3 et tw=78 :
+.. vim: set ts=3 sts=3 sw=3 et tw=78 spelllang=es :
projects / z.facultad / 75.00 / informe.git / blobdiff