X-Git-Url: https://git.llucax.com/z.facultad/75.00/informe.git/blobdiff_plain/429e5b716917b04ac71d68784a7a737c188bea76..refs/heads/master:/source/gc.rst?ds=inline diff --git a/source/gc.rst b/source/gc.rst index ff79b4f..66c64bd 100644 --- a/source/gc.rst +++ b/source/gc.rst @@ -1,10 +1,4 @@ -.. 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 @@ -159,9 +153,9 @@ está almacenada en otra celda *viva* del *heap*. 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. @@ -196,10 +190,11 @@ fueron visitados componen el *live set*; el resto de los vértices son 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*. + 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:: @@ -214,7 +209,7 @@ Más formalmente, Definimos: 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 + Decimos que :math:`M` está *conectado* a :math:`N` si y sólo si existe un camino de :math:`M` a :math:`N`. .. math:: @@ -222,9 +217,9 @@ Más formalmente, Definimos: 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. + 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:: @@ -233,14 +228,14 @@ Más formalmente, Definimos: \right\rbrace *Basura* - la basura, o celdas *muertas*, quedan determinadas entonces por todas las + 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`). @@ -592,10 +587,11 @@ 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 @@ -647,7 +643,7 @@ recolectores a lo largo de este documento. 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 + 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 @@ -660,16 +656,16 @@ Servicios utilizados por el recolector son los siguientes: 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 + 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. + 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 + 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 @@ -679,7 +675,7 @@ Y los servicios básicos proporcionados por el recolector son los siguientes: :math:`src \to old`. :math:`del(cell)` - este servicio, según el algoritmo, puede ser utilizado para informar un + 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 @@ -690,9 +686,9 @@ Y los servicios básicos proporcionados por el recolector son los siguientes: \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. + 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 @@ -1267,7 +1263,7 @@ contador de ``h2`` que queda en 0, transformándose en *basura* (ver figura }; h1 [ label = "h1\n0| l| r" ]; - h2 [ label = "h2\n1| l| r" ]; + h2 [ label = "h2\n0| l| r" ]; h3 [ label = "h3\n2| l\n*| r" ]; h4 [ label = "h4\n1| l| r" ]; h5 [ label = "h5\n2| l| r" ]; @@ -1335,7 +1331,7 @@ de actualizar la referencia ``h3.l`` para que apunte a ``h5`` (ver figura }; h1 [ label = "h1\n0| l| r" ]; - h2 [ label = "h2\n1| l| r" ]; + h2 [ label = "h2\n0| l| r" ]; h3 [ label = "h3\n2| l\n*| r" ]; h4 [ label = "h4\n0| l| r" ]; h5 [ label = "h5\n2| l| r" ]; @@ -1388,7 +1384,7 @@ de actualizar la referencia ``h3.l`` para que apunte a ``h5`` (ver figura }; h1 [ label = "h1\n0| l| r" ]; - h2 [ label = "h2\n1| l| r" ]; + h2 [ label = "h2\n0| l| r" ]; h3 [ label = "h3\n2| l\n*| r" ]; h4 [ label = "h4\n0| l| r" ]; h5 [ label = "h5\n1| l| r" ]; @@ -1734,13 +1730,13 @@ recolectores deben estar íntimamente relacionados con el *low level 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 asignar:: +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 @@ -1768,6 +1764,7 @@ a asignar:: 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) @@ -2102,13 +2099,9 @@ conectividad completo). La recolección se dispara usualmente cuando el *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 ` (directa) y *traicing garbage collection* (indirecta). Prácticamente todos los recolectores menos el :ref:`conteo de referencias -` están dentro de esta última categoría (como por ejemplo, el -:ref:`marcado y barrido ` y :ref:`copia de semi-espacio -`). +` están dentro de esta categoría (como por ejemplo, el :ref:`marcado +y barrido ` y :ref:`copia de semi-espacio `). Otros ejemplos de recolectores modernos *directos* son el recolector de basura de Python_ [NAS00]_ y [LINS05]_ (aunque ambos tiene un algoritmo *indirecto* @@ -2336,17 +2329,17 @@ y barrido ` no lo hacen. Además hay otro algoritmo bastante 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 ` 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 ` 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 @@ -2357,8 +2350,8 @@ o no. Esto trae una variada cantidad de problemas, como retención de celdas 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. @@ -2455,7 +2448,7 @@ completo). 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 de separar en distintas áreas grupos de tipos que no pueden tener referencias