Mencionar ionice(1) en la metodología de pruebas

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

diff --git a/source/gc.rst b/source/gc.rst
index ff79b4fd35994a13242ca71f836f75ed49d88384..66c64bdbc9efaf360630d7776e8b63f044000445 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
-
-

 .. _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,14 +228,14 @@ 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`).
 
 


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


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


@@ -1267,7 +1263,7 @@ contador de ``h2`` que queda en 0, transformándose en *basura* (ver figura
             };
 
             h1 [ label = "h1\n0|<l> l|<r> r" ];
             };
 
             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" ];
             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" ];


@@ -1335,7 +1331,7 @@ de actualizar la referencia ``h3.l`` para que apunte a ``h5`` (ver figura
             };
 
             h1 [ label = "h1\n0|<l> l|<r> r" ];
             };
 
             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" ];
             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" ];


@@ -1388,7 +1384,7 @@ de actualizar la referencia ``h3.l`` para que apunte a ``h5`` (ver figura
             };
 
             h1 [ label = "h1\n0|<l> l|<r> r" ];
             };
 
             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" ];
             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" ];


@@ -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
 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
 
    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
    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)
          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*.
 *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*


@@ -2336,17 +2329,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 +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
 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.


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