Aclarar explicación sobre abstracción tri-color

[z.facultad/75.00/informe.git] / source / gc.rst

diff --git a/source/gc.rst b/source/gc.rst
index 1998a31d558cd172bc8735f2a2d9c404867269ef..1bf5867a85eabd449157e2fb303ccee90b2d2cd2 100644 (file)
--- 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, CORREGIDO
-
-

 .. _gc:
 
 Recolección de basura
 .. _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
 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.
 
 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*
 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::
 
 
    .. math::
 


@@ -214,7 +209,7 @@ Más formalmente, Definimos:
    interior* puede ser un *vértice terminal*.
 
 *Conexión*
    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::
    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*
       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::
 
 
    .. math::
 


@@ -233,20 +228,20 @@ Más formalmente, Definimos:
       \right\rbrace
 
 *Basura*
       \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
 
    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`).
 
 
 :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*.
 
    Distintas partes de la memoria, incluyendo relación entre *basura*, *live
    set*, *heap* y *root set*.


@@ -321,7 +316,7 @@ siguiente (asumiendo que partimos con todos los vértices sin marcar)
    function mark(v) is
       if not v.marked
          v.marked = true
    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
             mark(dst)
 
    function mark_phase() is


@@ -349,11 +344,11 @@ con el marcado del grafo completo, dejando sin marcar solamente las celdas
 *basura* (en blanco).
 
 
 *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.
 
 
       Se comienza a marcar el grafo por la raíz r0.
 


@@ -386,7 +381,7 @@ con el marcado del grafo completo, dejando sin marcar solamente las celdas
 
          }
 
 
          }
 

-   .. subfig::
+   .. subflt::

 
       Luego de marcar el nodo ``h1``, se procede al ``h2``.
 
 
       Luego de marcar el nodo ``h1``, se procede al ``h2``.
 


@@ -420,7 +415,7 @@ con el marcado del grafo completo, dejando sin marcar solamente las celdas
 
          }
 
 
          }
 

-   .. subfig::
+   .. subflt::

 
       Luego sigue el nodo h5.
 
 
       Luego sigue el nodo h5.
 


@@ -456,11 +451,11 @@ con el marcado del grafo completo, dejando sin marcar solamente las celdas
          }
 
 
          }
 
 

-.. 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.
 
       El nodo h5 tiene una arista al h1, pero el h1 ya fue visitado, por lo
       tanto no se visita nuevamente.


@@ -496,7 +491,7 @@ con el marcado del grafo completo, dejando sin marcar solamente las celdas
 
          }
 
 
          }
 

-   .. 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.
 
       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.


@@ -533,7 +528,7 @@ con el marcado del grafo completo, dejando sin marcar solamente las celdas
 
          }
 
 
          }
 

-   .. 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
 
       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


@@ -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
 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
 
 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


@@ -608,7 +604,7 @@ vacíos)::
       while not gray_set.empty()
          v = gray_set.pop()
          black_set.add(v)
       while not gray_set.empty()
          v = gray_set.pop()
          black_set.add(v)

-         for (src, dst) in v.edges
+         foreach (src, dst) in v.edges

             if dst in white_set
                white_set.remove(dst)
                gray_set.add(dst)
             if dst in white_set
                white_set.remove(dst)
                gray_set.add(dst)


@@ -647,7 +643,7 @@ recolectores a lo largo de este documento.
 Servicios utilizados por el recolector son los siguientes:
 
 :math:`alloc() \to cell`
 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
    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)`
    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`
    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)`
 
 :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
    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)`
    :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
    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()`
    \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
 
 No todos los servicios son implementados por todos los recolectores, pero son
 lo suficientemente comunes como para describirlos de forma general en esta


@@ -844,13 +840,13 @@ conduce al decremento del contador de ``h2`` y ``h3`` que permanecen en el
 *live set* ya que sus contadores siguen siendo mayores a 0 (ver figura
 :vref:`fig:gc-rc-rm-2`).
 
 *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).
 
 
    Eliminación de la referencia ``r0`` :math:`\to` ``h1`` (parte 1).
 

-   .. subfig::
+   .. subflt::

 
       Estado inicial del grafo de conectividad.
 
 
       Estado inicial del grafo de conectividad.
 


@@ -897,7 +893,7 @@ conduce al decremento del contador de ``h2`` y ``h3`` que permanecen en el
 
          }
 
 
          }
 

-   .. subfig::
+   .. subflt::

 
       Al ejecutarse ``update(r0, null)``, se comienza por visitar la celda
       ``h1``.
 
       Al ejecutarse ``update(r0, null)``, se comienza por visitar la celda
       ``h1``.


@@ -945,7 +941,7 @@ conduce al decremento del contador de ``h2`` y ``h3`` que permanecen en el
 
          }
 
 
          }
 

-   .. subfig::
+   .. subflt::

 
       Se decrementa el contador de ``h1`` quedando en 0 (pasa a ser *basura*).
       Se elimina primero ``h1.l`` y luego ``h1.r``.
 
       Se decrementa el contador de ``h1`` quedando en 0 (pasa a ser *basura*).
       Se elimina primero ``h1.l`` y luego ``h1.r``.


@@ -999,14 +995,14 @@ conduce al decremento del contador de ``h2`` y ``h3`` que permanecen en el
          }
 
 
          }
 
 

-.. fig:: fig:gc-rc-rm-2
+.. flt:: fig:gc-rc-rm-2

    :padding: 0.5
 
    :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).
 
 
    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*).
 
       Se decrementa el contador de ``h2`` pero no queda en 0 (permanece en el
       *live set*).


@@ -1059,7 +1055,7 @@ conduce al decremento del contador de ``h2`` y ``h3`` que permanecen en el
 
          }
 
 
          }
 

-   .. subfig::
+   .. subflt::

 
       El contador de ``h3`` tampoco queda en 0, sigue en el *live set*.
 
 
       El contador de ``h3`` tampoco queda en 0, sigue en el *live set*.
 


@@ -1119,14 +1115,14 @@ se elimina alguna celda que apuntaba a ésta. Luego se procede a decrementar el
 contador de ``h2`` que queda en 0, transformándose en *basura* (ver figura
 :vref:`fig:gc-rc-up-1`).
 
 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 ``h3.l`` :math:`\to` ``h2`` a ``h3.l`` :math:`\to`
    ``h5`` (parte 1).
 
 
    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``.
 
 
       Comienza ``update(h3.l, h5)``, se incrementa el contador de ``h5``.
 


@@ -1179,7 +1175,7 @@ contador de ``h2`` que queda en 0, transformándose en *basura* (ver figura
 
          }
 
 
          }
 

-   .. subfig::
+   .. subflt::

 
       Luego se procede a visitar la antigua referencia de ``h3.l`` (``h2``).
 
 
       Luego se procede a visitar la antigua referencia de ``h3.l`` (``h2``).
 


@@ -1232,7 +1228,7 @@ contador de ``h2`` que queda en 0, transformándose en *basura* (ver figura
 
          }
 
 
          }
 

-   .. subfig::
+   .. subflt::

 
       Se decrementa el contador de ``h2`` y queda en 0 (pasa a ser *basura*).
       Se eliminan las referencias a las hijas.
 
       Se decrementa el contador de ``h2`` y queda en 0 (pasa a ser *basura*).
       Se eliminan las referencias a las hijas.


@@ -1293,14 +1289,14 @@ a apuntar a ``h5``) así que permanece en el *live set*. Finalmente se termina
 de actualizar la referencia ``h3.l`` para que apunte a ``h5`` (ver figura
 :vref:`fig:gc-rc-up-2`).
 
 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 ``h3.l`` :math:`\to` ``h2`` a ``h3.l`` :math:`\to`
    ``h5`` (parte 2).
 
 
    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``.
 
       Se decrementa el contador de ``h4`` quedando en 0, pasa a ser *basura*.
       Se continúa con ``h5``.


@@ -1354,7 +1350,7 @@ de actualizar la referencia ``h3.l`` para que apunte a ``h5`` (ver figura
 
          }
 
 
          }
 

-   .. subfig::
+   .. subflt::

 
       Se decrementa el contador de ``h5`` pero sigue siendo mayor que 0.
 
 
       Se decrementa el contador de ``h5`` pero sigue siendo mayor que 0.
 


@@ -1407,7 +1403,7 @@ de actualizar la referencia ``h3.l`` para que apunte a ``h5`` (ver figura
 
          }
 
 
          }
 

-   .. subfig::
+   .. subflt::

 
       Se termina por actualizar la referencia de ``h3.l`` para que apunte
       a ``h5``.
 
       Se termina por actualizar la referencia de ``h3.l`` para que apunte
       a ``h5``.


@@ -1473,15 +1469,15 @@ referencias externas y por lo tanto deberían ser *basura* también (``h5``), no
 pueden ser recicladas y su memoria es perdida (ver figura
 :vref:`fig:gc-rc-cycle`).
 
 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
 
    :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).
 
 
    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``.
 
 
       El ejecutarse ``update(r1, null)`` se visita la celda ``h3``.
 


@@ -1535,7 +1531,7 @@ pueden ser recicladas y su memoria es perdida (ver figura
 
          }
 
 
          }
 

-   .. subfig::
+   .. subflt::

 
       Se decrementa el contador de ``h3`` pero sigue siendo mayor que 0 por el
       ciclo.
 
       Se decrementa el contador de ``h3`` pero sigue siendo mayor que 0 por el
       ciclo.


@@ -1684,9 +1680,9 @@ sus *low level allocators*).
    sucede y se acumulan muchos *huecos* se dice que la memoria está
    *fragmentada*.
 
    sucede y se acumulan muchos *huecos* se dice que la memoria está
    *fragmentada*.
 

-.. fig:: fig:gc-copy
+.. flt:: fig:gc-copy

 
 

-   Estructura del *heap* de un recolector con copia de semi-espacios.
+   Estructura del *heap* de un recolector con copia de semi-espacios

 
    .. aafig::
       :aspect: 70
 
    .. aafig::
       :aspect: 70


@@ -1818,11 +1814,11 @@ apunta a ``h3``, por lo tanto ésta es movida al *Tospace* primero, dejando una
 *forwarding address* a la nueva ubicación (ver figura
 :vref:`fig:gc-copy-ex-1`).
 
 *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.
 
       Estructura inicial del *heap*. El *Fromspace* está complete y se inicial
       la recolección.


@@ -1853,7 +1849,7 @@ apunta a ``h3``, por lo tanto ésta es movida al *Tospace* primero, dejando una
          | "Tospace"                                        |
          +--------------------------------------------------+
 
          | "Tospace"                                        |
          +--------------------------------------------------+
 

-   .. subfig::
+   .. subflt::

 
       Se sigue la referencia del *root set*, copiando ``h3`` al *Tospace*
       y dejando una *forwarding address*.
 
       Se sigue la referencia del *root set*, copiando ``h3`` al *Tospace*
       y dejando una *forwarding address*.


@@ -1895,11 +1891,11 @@ sido visitada, solamente se actualiza la referencia apuntando a la nueva
 ubicación de ``h2`` pero no se vuelve a copiar la celda (ver figura
 :vref:`fig:gc-copy-ex-2`).
 
 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*.
 
       Se sigue :math:`h3 \to h2`, copiando ``h2`` al *Tospace* y dejando una
       *forwarding address*.


@@ -1930,7 +1926,7 @@ ubicación de ``h2`` pero no se vuelve a copiar la celda (ver figura
          | "Tospace"                                        |
          +--------------------------------------------------+
 
          | "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
 
       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


@@ -1969,11 +1965,11 @@ semi-espacios y se actualiza la referencia del *root set* para que apunte a la
 nueva ubicación de ``h3``, como se muestra en la figura
 :vref:`fig:gc-copy-ex-3`.
 
 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*.
 
       Se sigue :math:`h1 \to h4` copiando `h4`` al *Tospace* y dejando una
       *forwarding address*.


@@ -2004,7 +2000,7 @@ nueva ubicación de ``h3``, como se muestra en la figura
          | "Tospace"   \------/                             |
          +--------------------------------------------------+
 
          | "Tospace"   \------/                             |
          +--------------------------------------------------+
 

-   .. subfig::
+   .. subflt::

 
       Se finaliza la recolección, se intercambian los roles de los
       semi-espacios y se actualiza la referencia del *root set*.
 
       Se finaliza la recolección, se intercambian los roles de los
       semi-espacios y se actualiza la referencia del *root set*.


@@ -2102,13 +2098,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*.
 *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
 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*
 
 Otros ejemplos de recolectores modernos *directos* son el recolector de basura
 de Python_ [NAS00]_ y [LINS05]_ (aunque ambos tiene un algoritmo *indirecto*


@@ -2165,12 +2157,12 @@ clase de colectores que si bien son *stop-the-world*, utilizan todos los hilos
 disponibles para realizar la recolección (ver figura
 :vref:`fig:gc-concurrent`).
 
 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
 
    Distintos tipos de recolectores según el comportamiento en ambientes

-   multi-hilo.
+   multi-hilo

 
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world*.
 
 
       *Stop-the-world*.
 


@@ -2189,7 +2181,7 @@ disponibles para realizar la recolección (ver figura
          |         HH Mutator           ZZ Inactivo         XX Recolector    |
          |___________________________________________________________________|
 
          |         HH Mutator           ZZ Inactivo         XX Recolector    |
          |___________________________________________________________________|
 

-   .. subfig::
+   .. subflt::

 
       Paralelo.
 
 
       Paralelo.
 


@@ -2208,7 +2200,7 @@ disponibles para realizar la recolección (ver figura
          |         HH Mutator           ZZ Inactivo         XX Recolector    |
          |___________________________________________________________________|
 
          |         HH Mutator           ZZ Inactivo         XX Recolector    |
          |___________________________________________________________________|
 

-   .. subfig::
+   .. subflt::

 
       Concurrente.
 
 
       Concurrente.
 


@@ -2336,17 +2328,17 @@ y barrido <gc_mark_sweep>` 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
 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:
 
 
 
 
 .. _gc_conserv:
 

-Recolectores conservativos vs precisos
+Recolectores conservativos versus precisos

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Los recolectores *conservativos* son aquellos que tienen la capacidad de poder
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Los recolectores *conservativos* son aquellos que tienen la capacidad de poder


@@ -2357,8 +2349,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
 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.
 
 .. [#gcflasepos] Esto es lo que se conoce como un *falso positivo*, algo que
    aparenta ser un puntero pero en realidad no lo es.


@@ -2406,11 +2398,11 @@ 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
 
 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::
       :scale: 110
 
    .. aafig::
       :scale: 110


@@ -2455,7 +2447,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
 
 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
 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