Agregar gente que hace Software Libre a Agradecimientos

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

diff --git a/source/dgc.rst b/source/dgc.rst
index 09c0c21a3300467753bf3bbb3e6b66e17676efc6..837774a2a0959bffdde09c667bd9841a43afd007 100644 (file)
--- a/source/dgc.rst
+++ b/source/dgc.rst
@@ -1,12 +1,4 @@
 
 

-.. Describe más detalladamente los problemas actuales del recolector de
-   basura de D, sentando las bases para el análisis de los requerimientos
-   de recolección de basura en dicho lenguaje (se explica por qué las
-   particularidades descriptas en la sección anterior complican la
-   recolección de basura y cuales son las que más molestan).
-   ESTADO: TERMINADO
-
-

 .. _dgc:
 
 Recolección de basura en D
 .. _dgc:
 
 Recolección de basura en D


@@ -63,7 +55,7 @@ mismas (o más) limitaciones.
 El control sobre la alineación de memoria es otra complicación sobre el
 recolector de basura, incluso aunque éste sea conservativo. Dado que tratar la
 memoria de forma conservativa byte a byte sería impracticable (tanto por la
 El control sobre la alineación de memoria es otra complicación sobre el
 recolector de basura, incluso aunque éste sea conservativo. Dado que tratar la
 memoria de forma conservativa byte a byte sería impracticable (tanto por la

-cantidad de falsos positivos que esto provocaría como por el impacto en el
+cantidad de *falsos positivos* que esto provocaría como por el impacto en el

 rendimiento por el exceso de posibles punteros a revisar, además de lo
 ineficiente que es operar sobre memoria no alineada), en general el recolector
 asume que el usuario nunca va a tener la única referencia a un objeto en una
 rendimiento por el exceso de posibles punteros a revisar, además de lo
 ineficiente que es operar sobre memoria no alineada), en general el recolector
 asume que el usuario nunca va a tener la única referencia a un objeto en una


@@ -130,7 +122,7 @@ una función miembro llamada *destructor*, o ``~this()`` en D_). Esto significa
 que el recolector, al encontrar que no hay más referencias a un objeto, debe
 ejecutar el destructor.
 
 que el recolector, al encontrar que no hay más referencias a un objeto, debe
 ejecutar el destructor.
 

-La especificación dice:
+La especificación dice [DWDE]_:

 
    The garbage collector is not guaranteed to run the destructor for all
    unreferenced objects. Furthermore, the order in which the garbage collector
 
    The garbage collector is not guaranteed to run the destructor for all
    unreferenced objects. Furthermore, the order in which the garbage collector


@@ -238,9 +230,9 @@ dicho objeto.
    para indicar la continuación de un objeto grande (que ocupan más de una
    página).
 
    para indicar la continuación de un objeto grande (que ocupan más de una
    página).
 

-.. fig:: fig:dgc-org
+.. flt:: fig:dgc-org

 
 

-   Organización del *heap* del recolector de basura actual de D.
+   Organización del *heap* del recolector de basura actual de D

 
    Organización del *heap*. En este ejemplo todos los *pools* tienen 2 páginas
    excepto el *pool* 2 que tiene una sola.  El tamaño de bloque que almacena
 
    Organización del *heap*. En este ejemplo todos los *pools* tienen 2 páginas
    excepto el *pool* 2 que tiene una sola.  El tamaño de bloque que almacena


@@ -304,9 +296,9 @@ parte de una :ref:`lista de libres <gc_free_list>` (ver figura
 :vref:`fig:dgc-free-list`). Esto permite asignar objetos relativamente
 pequeños de forma bastante eficiente.
 
 :vref:`fig:dgc-free-list`). Esto permite asignar objetos relativamente
 pequeños de forma bastante eficiente.
 

-.. fig:: fig:dgc-free-list
+.. flt:: fig:dgc-free-list

 
 

-   Ejemplo de listas de libres.
+   Ejemplo de listas de libres

 
    .. digraph:: dgc_free_list
 
 
    .. digraph:: dgc_free_list
 


@@ -338,11 +330,11 @@ Atributos de *pool*
 Cada *pool* tiene la siguiente información asociada:
 
 *number_of_pages*
 Cada *pool* tiene la siguiente información asociada:
 
 *number_of_pages*

-   cantidad de páginas que tiene. Esta cantidad es fija en toda la vida de un
+   Cantidad de páginas que tiene. Esta cantidad es fija en toda la vida de un

    *pool*.
 
 *pages*
    *pool*.
 
 *pages*

-   bloque de memoria contiguo de tamaño ``PAGE_SIZE * number_of_pages``
+   Bloque de memoria contiguo de tamaño ``PAGE_SIZE * number_of_pages``

    (siendo ``PAGE_SIZE`` el tamaño de página, que normalmente son 4096 bytes).
 
 
    (siendo ``PAGE_SIZE`` el tamaño de página, que normalmente son 4096 bytes).
 
 


@@ -357,13 +349,13 @@ Una página siempre almacena bloques del mismo tamaño, que pueden ser 16, 32,
 significado especial:
 
 ``FREE``
 significado especial:
 
 ``FREE``

-   indica que la página está completamente libre y que la página está
+   Indica que la página está completamente libre y que la página está

    disponible para albergar cualquier tamaño de bloque que sea necesario (pero
    una vez que se le asignó un nuevo tamaño de bloque ya no puede ser cambiado
    hasta que la página vuelva a liberarse por completo).
 
 ``CONTINUATION``
    disponible para albergar cualquier tamaño de bloque que sea necesario (pero
    una vez que se le asignó un nuevo tamaño de bloque ya no puede ser cambiado
    hasta que la página vuelva a liberarse por completo).
 
 ``CONTINUATION``

-   indica que esta página es la continuación de un objeto grande (es decir,
+   Indica que esta página es la continuación de un objeto grande (es decir,

    que ocupa una o más páginas). Luego se presentan más detalles sobre objetos
    grandes.
 
    que ocupa una o más páginas). Luego se presentan más detalles sobre objetos
    grandes.
 


@@ -376,28 +368,28 @@ Atributos de bloque
 Cada bloque tiene asociados varios atributos:
 
 *mark*
 Cada bloque tiene asociados varios atributos:
 
 *mark*

-   utilizado en la fase de :ref:`marcado <dgc_algo_mark>`, indica que un nodo
+   Utilizado en la fase de :ref:`marcado <dgc_algo_mark>`, indica que un nodo

    ya fue visitado (serían las celdas *negras* en la :ref:`abstracción
    tricolor <gc_intro_tricolor>`).
 
 *scan*
    ya fue visitado (serían las celdas *negras* en la :ref:`abstracción
    tricolor <gc_intro_tricolor>`).
 
 *scan*

-   utilizado también en la fase de :ref:`marcado <dgc_algo_mark>`, indica que
+   Utilizado también en la fase de :ref:`marcado <dgc_algo_mark>`, indica que

    una celda visitada todavía tiene *hijas* sin marcar (serían las celdas
    *grises* en la :ref:`abstracción tricolor <gc_intro_tricolor>`).
 
 *free*
    una celda visitada todavía tiene *hijas* sin marcar (serían las celdas
    *grises* en la :ref:`abstracción tricolor <gc_intro_tricolor>`).
 
 *free*

-   indica que el bloque está libre (no está siendo utilizado por ningún objeto
+   Indica que el bloque está libre (no está siendo utilizado por ningún objeto

    *vivo*). Esto es necesario solo por la forma en la que realiza el
    :ref:`marcado <dgc_algo_mark>` y :ref:`barrido <dgc_algo_sweep>` en el
    :ref:`algoritmo actual <dgc_algo>` (las celdas con el atributo este
    atributo son tomadas como *basura* aunque estén marcadas con *mark*).
 
 *final*
    *vivo*). Esto es necesario solo por la forma en la que realiza el
    :ref:`marcado <dgc_algo_mark>` y :ref:`barrido <dgc_algo_sweep>` en el
    :ref:`algoritmo actual <dgc_algo>` (las celdas con el atributo este
    atributo son tomadas como *basura* aunque estén marcadas con *mark*).
 
 *final*

-   indica que el bloque contiene un objeto que tiene un destructor (que debe
+   Indica que el bloque contiene un objeto que tiene un destructor (que debe

    ser llamado cuando la celda pasa de *viva* a *basura*).
 
 *noscan*
    ser llamado cuando la celda pasa de *viva* a *basura*).
 
 *noscan*

-   indica que el bloque contiene un objeto que no tiene punteros y por lo
+   Indica que el bloque contiene un objeto que no tiene punteros y por lo

    tanto no debe ser marcado de forma conservativa (no tiene *hijas*).
 
 
    tanto no debe ser marcado de forma conservativa (no tiene *hijas*).
 
 


@@ -508,7 +500,7 @@ La función ``mark_free_lists()`` por su parte se encarga de activar el bit
 de marcado (que es iterativa y realiza varias pasadas sobre **todo** el
 *heap*, incluyendo las celdas libres) no visite las celdas libres perdiendo
 tiempo sin sentido y potencialmente manteniendo *vivas* celdas que en
 de marcado (que es iterativa y realiza varias pasadas sobre **todo** el
 *heap*, incluyendo las celdas libres) no visite las celdas libres perdiendo
 tiempo sin sentido y potencialmente manteniendo *vivas* celdas que en

-realidad son *basura* (falsos positivos)::
+realidad son *basura* (*falsos positivos*)::

 
    function mark_free_lists() is
       foreach free_list in heap
 
    function mark_free_lists() is
       foreach free_list in heap


@@ -854,9 +846,9 @@ siguiente función, que devuelve al *low level allocator* los *pools*
 completamente libres::
 
    function minimize() is
 completamente libres::
 
    function minimize() is

-      for pool in heap
+      foreach pool in heap

          all_free = true
          all_free = true

-         for page in pool
+         foreach page in pool

             if page.block_size is not FREE
                all_free = false
                break
             if page.block_size is not FREE
                all_free = false
                break


@@ -967,11 +959,11 @@ facilitar la comprensión):
 
 Raíces definidas por el usuario
    *roots* (*nroots*, *rootdim*)
 
 Raíces definidas por el usuario
    *roots* (*nroots*, *rootdim*)

-      arreglo variable de punteros simples que son tomados como raíces
+      Arreglo variable de punteros simples que son tomados como raíces

       provistas por el usuario.
 
    *ranges* (*nranges*, *rangedim*)
       provistas por el usuario.
 
    *ranges* (*nranges*, *rangedim*)

-      arreglo variable de rangos de memoria que deben ser revisados (de forma
+      Arreglo variable de rangos de memoria que deben ser revisados (de forma

       conservativa) como raíces provistas por el usuario. Un rango es una
       estructura con dos punteros: ``pbot`` y ``ptop``. Toda la memoria entre
       estos dos punteros se toma, palabra por palabra, como una raíz del
       conservativa) como raíces provistas por el usuario. Un rango es una
       estructura con dos punteros: ``pbot`` y ``ptop``. Toda la memoria entre
       estos dos punteros se toma, palabra por palabra, como una raíz del


@@ -979,7 +971,7 @@ Raíces definidas por el usuario
 
 Estado interno del recolector
    *anychanges*
 
 Estado interno del recolector
    *anychanges*

-      variable que indica si en la fase de marcado se encontraron nuevas
+      Variable que indica si en la fase de marcado se encontraron nuevas

       celdas con punteros que deban ser visitados. Otra forma de verlo es como
       un indicador de si el conjunto de celdas *grises* está vacío luego de
       una iteración de marcado (utilizando la :ref:`abstracción tricolor
       celdas con punteros que deban ser visitados. Otra forma de verlo es como
       un indicador de si el conjunto de celdas *grises* está vacío luego de
       una iteración de marcado (utilizando la :ref:`abstracción tricolor


@@ -987,35 +979,35 @@ Estado interno del recolector
       presentada en :ref:`dgc_algo_mark`.
 
    *inited*
       presentada en :ref:`dgc_algo_mark`.
 
    *inited*

-      indica si el recolector fue inicializado.
+      Indica si el recolector fue inicializado.

 
    *stackBottom*
 
    *stackBottom*

-      puntero a la base del *stack* (asumiendo que el stack crece hacia arriba).
+      Puntero a la base del *stack* (asumiendo que el stack crece hacia arriba).

       Se utiliza para saber por donde comenzar a visitar el *stack* de forma
       conservativa, tomándolo con una raíz del recolector.
 
    *Pools* (*pooltable*, *npools*)
       Se utiliza para saber por donde comenzar a visitar el *stack* de forma
       conservativa, tomándolo con una raíz del recolector.
 
    *Pools* (*pooltable*, *npools*)

-      arreglo variable de punteros a estructuras ``Pool`` (ver más adelante).
+      Arreglo variable de punteros a estructuras ``Pool`` (ver más adelante).

       Este arreglo se mantiene siempre ordenado de menor a mayor según la
       dirección de memoria de la primera página que almacena.
 
    *bucket*
       Este arreglo se mantiene siempre ordenado de menor a mayor según la
       dirección de memoria de la primera página que almacena.
 
    *bucket*

-      listas de libres. Es un arreglo de estructuras ``List`` utilizadas para
+      Listas de libres. Es un arreglo de estructuras ``List`` utilizadas para

       guardar la listas de libres de todos los tamaños de bloques posibles (ver
       más adelante).
 
 Atributos que cambian el comportamiento
    *noStack*
       guardar la listas de libres de todos los tamaños de bloques posibles (ver
       más adelante).
 
 Atributos que cambian el comportamiento
    *noStack*

-      indica que no debe tomarse al *stack* como raíz del recolector. Esto es
+      Indica que no debe tomarse al *stack* como raíz del recolector. Esto es

       muy poco seguro y no debería ser utilizado nunca, salvo casos
       extremadamente excepcionales.
 
    *log*
       muy poco seguro y no debería ser utilizado nunca, salvo casos
       extremadamente excepcionales.
 
    *log*

-      indica si se debe guardar un registro de la actividad del recolector. Es
+      Indica si se debe guardar un registro de la actividad del recolector. Es

       utilizado principalmente para depuración.
 
    *disabled*
       utilizado principalmente para depuración.
 
    *disabled*

-      indica que no se deben realizar recolecciones implícitamente. Si al
+      Indica que no se deben realizar recolecciones implícitamente. Si al

       tratar de asignar memoria no se puede hallar celdas libres en el *heap*
       del recolector, se pide más memoria al sistema operativo sin correr una
       recolección para intentar recuperar espacio. Esto es particularmente
       tratar de asignar memoria no se puede hallar celdas libres en el *heap*
       del recolector, se pide más memoria al sistema operativo sin correr una
       recolección para intentar recuperar espacio. Esto es particularmente


@@ -1025,14 +1017,14 @@ Atributos que cambian el comportamiento
 
 Optimizaciones
    *p_cache*, *size_cache*
 
 Optimizaciones
    *p_cache*, *size_cache*

-      obtener el tamaño de un bloque dado un puntero es una tarea costosa
+      Obtener el tamaño de un bloque dado un puntero es una tarea costosa

       y común. Para evitarla en casos donde se calcula de forma sucesiva el
       tamaño del mismo bloque (como puede ocurrir al concatenar arreglos
       dinámicos) se guarda el último calculado en estas variables a modo de
       *caché*.
 
    *minAddr*, *maxAddr*
       y común. Para evitarla en casos donde se calcula de forma sucesiva el
       tamaño del mismo bloque (como puede ocurrir al concatenar arreglos
       dinámicos) se guarda el último calculado en estas variables a modo de
       *caché*.
 
    *minAddr*, *maxAddr*

-      punteros al principio y fin del *heap*. Pueden haber *huecos* entre
+      Punteros al principio y fin del *heap*. Pueden haber *huecos* entre

       estos dos punteros que no pertenezcan al *heap* pero siempre se cumple
       que si un puntero apunta al *heap* debe estar en este rango. Esto es
       útil para hacer un cálculo rápido para descartar punteros que fueron
       estos dos punteros que no pertenezcan al *heap* pero siempre se cumple
       que si un puntero apunta al *heap* debe estar en este rango. Esto es
       útil para hacer un cálculo rápido para descartar punteros que fueron


@@ -1058,58 +1050,58 @@ C ``malloc()``, ``realloc()`` y ``free()`` directamente.
 La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura
 :vref:`fig:dgc-pool`):
 
 La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura
 :vref:`fig:dgc-pool`):
 

+.. flt:: fig:dgc-pool
+
+   Vista gráfica de la estructura de un *pool* de memoria
+
+   .. aafig::
+      :scale: 120
+
+                /---  "baseAddr"    "ncommitted = i"          "topAddr" ---\
+                |                       V                                  |
+                |/                      |/                                 |/
+                +----  "committed" -----+-------  "no committed" ----------+
+               /|                      /|                                 /|
+                V                       V                                  V
+                +--------+--------+-----+--------+-----+-------------------+
+        páginas |   0    |   0    | ... |   i    | ... |    "npages - 1"   |
+                +--------+--------+-----+--------+-----+-------------------+
+                    A        A      A       A      A           A
+                    |        |      |       |      |           |
+                +--------+--------+-----+--------+-----+-------------------+
+      pagetable | Bins 0 | Bins 1 | ... | Bins i | ... | "Bins (npages-1)" |
+                +--------+--------+-----+--------+-----+-------------------+
+

 *baseAddr* y *topAddr*
 *baseAddr* y *topAddr*

-   punteros al comienzo y fin de la memoria que almacena todas las páginas del
+   Punteros al comienzo y fin de la memoria que almacena todas las páginas del

    *pool* (*baseAddr* es análogo al atributo *pages* utilizado en las
    secciones anteriores para mayor claridad).
 
 *mark*, *scan*, *freebits*, *finals*, *noscan*
    *pool* (*baseAddr* es análogo al atributo *pages* utilizado en las
    secciones anteriores para mayor claridad).
 
 *mark*, *scan*, *freebits*, *finals*, *noscan*

-   conjunto de bits (*bitsets*) para almacenar los indicadores descriptos en
+   Conjunto de bits (*bitsets*) para almacenar los indicadores descriptos en

    :ref:`dgc_org` para todos los bloques de todas las páginas del *pool*.
    *freebits* es análogo a *free* y *finals* a *final* en los atributos
    descriptos en las secciones anteriores.
 
 *npages*
    :ref:`dgc_org` para todos los bloques de todas las páginas del *pool*.
    *freebits* es análogo a *free* y *finals* a *final* en los atributos
    descriptos en las secciones anteriores.
 
 *npages*

-   cantidad de páginas que contiene este *pool* (fue nombrado
+   Cantidad de páginas que contiene este *pool* (fue nombrado

    *number_of_pages* en las secciones anteriores para mayor claridad).
 
 *ncommitted*
    *number_of_pages* en las secciones anteriores para mayor claridad).
 
 *ncommitted*

-   cantidad de páginas *encomendadas* al sistema operativo (*committed* en
+   Cantidad de páginas *encomendadas* al sistema operativo (*committed* en

    inglés). Este atributo no se mencionó anteriormente porque el manejo de
    páginas encomendadas le agrega una complejidad bastante notable al
    recolector y es solo una optimización para un sistema operativo en
    particular (Microsoft Windows).
 
 *pagetable*
    inglés). Este atributo no se mencionó anteriormente porque el manejo de
    páginas encomendadas le agrega una complejidad bastante notable al
    recolector y es solo una optimización para un sistema operativo en
    particular (Microsoft Windows).
 
 *pagetable*

-   arreglo de indicadores de tamaño de bloque de cada página de este *pool*.
+   Arreglo de indicadores de tamaño de bloque de cada página de este *pool*.

    Los indicadores válidos son ``B_16`` a ``B_2048`` (pasando por los valores
    posibles de bloque mencionados anteriormente, todos con el prefijo
    "``B_``"), ``B_PAGE``, ``B_PAGEPLUS`` (análogo a ``CONTINUATION``),
    ``B_UNCOMMITTED`` (valor que tienen las páginas que no fueron encomendadas
    aún) y ``B_FREE``.
 
    Los indicadores válidos son ``B_16`` a ``B_2048`` (pasando por los valores
    posibles de bloque mencionados anteriormente, todos con el prefijo
    "``B_``"), ``B_PAGE``, ``B_PAGEPLUS`` (análogo a ``CONTINUATION``),
    ``B_UNCOMMITTED`` (valor que tienen las páginas que no fueron encomendadas
    aún) y ``B_FREE``.
 

-.. fig:: fig:dgc-pool
-
-   Vista gráfica de la estructura de un *pool* de memoria.
-
-   .. aafig::
-      :scale: 120
-
-                /---  "baseAddr"    "ncommitted = i"          "topAddr" ---\
-                |                       V                                  |
-                |/                      |/                                 |/
-                +----  "committed" -----+-------  "no committed" ----------+
-               /|                      /|                                 /|
-                V                       V                                  V
-                +--------+--------+-----+--------+-----+-------------------+
-        páginas |   0    |   0    | ... |   i    | ... |    "npages - 1"   |
-                +--------+--------+-----+--------+-----+-------------------+
-                    A        A      A       A      A           A
-                    |        |      |       |      |           |
-                +--------+--------+-----+--------+-----+-------------------+
-      pagetable | Bins 0 | Bins 1 | ... | Bins i | ... | "Bins (npages-1)" |
-                +--------+--------+-----+--------+-----+-------------------+
-

 Como se observa, además de la información particular del *pool* se almacena
 toda la información de páginas y bloques enteramente en el *pool* también.
 Esto simplifica el manejo de que lo es memoria *pura* del *heap*, ya que queda
 Como se observa, además de la información particular del *pool* se almacena
 toda la información de páginas y bloques enteramente en el *pool* también.
 Esto simplifica el manejo de que lo es memoria *pura* del *heap*, ya que queda


@@ -1156,33 +1148,33 @@ para facilitar la comprensión. Los siguientes son métodos de la estructura
 
 Inicialización y terminación
    *initialize()*
 
 Inicialización y terminación
    *initialize()*

-      inicializa las estructuras internas del recolector para que pueda ser
+      Inicializa las estructuras internas del recolector para que pueda ser

       utilizado. Esta función la llama la biblioteca *runtime* antes de que el
       programa comience a correr.
 
    *Dtor()*
       utilizado. Esta función la llama la biblioteca *runtime* antes de que el
       programa comience a correr.
 
    *Dtor()*

-       libera todas las estructuras que utiliza el recolector.
+       Libera todas las estructuras que utiliza el recolector.

 
 Manipulación de raíces definidas por el usuario
    *addRoot(p)*, *removeRoot(p)*, *rootIter(dg)*
 
 Manipulación de raíces definidas por el usuario
    *addRoot(p)*, *removeRoot(p)*, *rootIter(dg)*

-      agrega, remueve e itera sobre las raíces simples definidas por el
+      Agrega, remueve e itera sobre las raíces simples definidas por el

       usuario.
 
    *addRange(pbot, ptop)*, *remove range(pbot)*, *rangeIter(dg)*
       usuario.
 
    *addRange(pbot, ptop)*, *remove range(pbot)*, *rangeIter(dg)*

-      agrega, remueve e itera sobre los rangos de raíces definidas por el
+      Agrega, remueve e itera sobre los rangos de raíces definidas por el

       usuario.
 
 Manipulación de indicadores
    *getBits(pool, biti)*
       usuario.
 
 Manipulación de indicadores
    *getBits(pool, biti)*

-      obtiene los indicadores especificados para el bloque de índice ``biti``
+      Obtiene los indicadores especificados para el bloque de índice ``biti``

       en el *pool* ``pool``.
 
    *setBits(pool, biti, mask)*
       en el *pool* ``pool``.
 
    *setBits(pool, biti, mask)*

-      establece los indicadores especificados en ``mask`` para el bloque de
+      Establece los indicadores especificados en ``mask`` para el bloque de

       índice ``biti`` en el *pool* ``pool``.
 
    *clrBits(pool, biti, mask)*
       índice ``biti`` en el *pool* ``pool``.
 
    *clrBits(pool, biti, mask)*

-      limpia los indicadores especificados en ``mask`` para el bloque de
+      Limpia los indicadores especificados en ``mask`` para el bloque de

       índice ``biti`` en el *pool* ``pool``.
 
    Cada bloque (*bin* en la terminología de la implementación del recolector)
       índice ``biti`` en el *pool* ``pool``.
 
    Cada bloque (*bin* en la terminología de la implementación del recolector)


@@ -1194,15 +1186,15 @@ Manipulación de indicadores
    compuesta por la conjunción de los siguientes valores:
 
    *FINALIZE*
    compuesta por la conjunción de los siguientes valores:
 
    *FINALIZE*

-      el objeto almacenado en el bloque tiene un destructor (indicador
+      El objeto almacenado en el bloque tiene un destructor (indicador

       *finals*).
 
    *NO_SCAN*
       *finals*).
 
    *NO_SCAN*

-      el objeto almacenado en el bloque no contiene punteros (indicador
+      El objeto almacenado en el bloque no contiene punteros (indicador

       *noscan*).
 
    *NO_MOVE*
       *noscan*).
 
    *NO_MOVE*

-      el objeto almacenado en el bloque no debe ser movido [#dgcmove]_.
+      El objeto almacenado en el bloque no debe ser movido [#dgcmove]_.

 
 .. [#dgcmove] Si bien el recolector actual no tiene la capacidad de mover
    objetos, la interfaz del recolector hacer que sea posible una
 
 .. [#dgcmove] Si bien el recolector actual no tiene la capacidad de mover
    objetos, la interfaz del recolector hacer que sea posible una


@@ -1212,38 +1204,38 @@ Manipulación de indicadores
 
 Búsquedas
    *findPool(p)*
 
 Búsquedas
    *findPool(p)*

-      busca el *pool* al que pertenece el objeto apuntado por ``p``.
+      Busca el *pool* al que pertenece el objeto apuntado por ``p``.

 
    *findBase(p)*
 
    *findBase(p)*

-      busca la dirección base (el inicio) del bloque apuntado por ``p``
+      Busca la dirección base (el inicio) del bloque apuntado por ``p``

       (``find_block()`` según la sección :ref:`dgc_algo_mark`).
 
    *findSize(p)*
       (``find_block()`` según la sección :ref:`dgc_algo_mark`).
 
    *findSize(p)*

-      busca el tamaño del bloque apuntado por ``p``.
+      Busca el tamaño del bloque apuntado por ``p``.

 
    *getInfo(p)*
 
    *getInfo(p)*

-      obtiene información sobre el bloque apuntado por ``p``. Dicha
+      Obtiene información sobre el bloque apuntado por ``p``. Dicha

       información se retorna en una estructura ``BlkInfo`` que contiene los
       siguientes atributos: ``base`` (dirección del inicio del bloque),
       ``size`` (tamaño del bloque) y ``attr`` (atributos o indicadores del
       bloque, los que se pueden obtener con ``getBits()``).
 
    *findBin(size)*
       información se retorna en una estructura ``BlkInfo`` que contiene los
       siguientes atributos: ``base`` (dirección del inicio del bloque),
       ``size`` (tamaño del bloque) y ``attr`` (atributos o indicadores del
       bloque, los que se pueden obtener con ``getBits()``).
 
    *findBin(size)*

-      calcula el tamaño de bloque más pequeño que pueda contener un objeto de
+      Calcula el tamaño de bloque más pequeño que pueda contener un objeto de

       tamaño ``size`` (``find_block_size()`` según lo visto en
       :ref:`dgc_algo_alloc`).
 
 Asignación de memoria
    *reserve(size)*
       tamaño ``size`` (``find_block_size()`` según lo visto en
       :ref:`dgc_algo_alloc`).
 
 Asignación de memoria
    *reserve(size)*

-      reserva un nuevo *pool* de al menos ``size`` bytes. El algoritmo nunca
+      Reserva un nuevo *pool* de al menos ``size`` bytes. El algoritmo nunca

       crea un *pool* con menos de 256 páginas (es decir, 1 MiB).
 
    *minimize()*
       crea un *pool* con menos de 256 páginas (es decir, 1 MiB).
 
    *minimize()*

-      minimiza el uso de la memoria retornando *pools* sin páginas usadas al
+      Minimiza el uso de la memoria retornando *pools* sin páginas usadas al

       sistema operativo.
 
    *newPool(n)*
       sistema operativo.
 
    *newPool(n)*

-      reserva un nuevo *pool* con al menos ``n`` páginas. Junto con
+      Reserva un nuevo *pool* con al menos ``n`` páginas. Junto con

       ``Pool.initialize()`` es análoga a ``new_pool()``, solo que esta función
       siempre incrementa el número de páginas a, al menos, 256 páginas (es
       decir, los *pools* son siempre mayores a 1 MiB). Si la cantidad de
       ``Pool.initialize()`` es análoga a ``new_pool()``, solo que esta función
       siempre incrementa el número de páginas a, al menos, 256 páginas (es
       decir, los *pools* son siempre mayores a 1 MiB). Si la cantidad de


@@ -1255,7 +1247,7 @@ Asignación de memoria
       *pools* de 8 MiB o la cantidad pedida, si ésta es mayor.
 
    *Pool.initialize(n_pages)*
       *pools* de 8 MiB o la cantidad pedida, si ésta es mayor.
 
    *Pool.initialize(n_pages)*

-      inicializa un nuevo *pool* de memoria. Junto con ``newPool()`` es
+      Inicializa un nuevo *pool* de memoria. Junto con ``newPool()`` es

       análoga a ``new_pool()``. Mientras ``newPool()`` es la encargada de
       calcular la cantidad de páginas y crear el objeto *pool*, esta función
       es la que pide la memoria al sistema operativo. Además inicializa los
       análoga a ``new_pool()``. Mientras ``newPool()`` es la encargada de
       calcular la cantidad de páginas y crear el objeto *pool*, esta función
       es la que pide la memoria al sistema operativo. Además inicializa los


@@ -1265,7 +1257,7 @@ Asignación de memoria
       ``finals`` de todo el *pool*.
 
    *allocPage(bin)*
       ``finals`` de todo el *pool*.
 
    *allocPage(bin)*

-      asigna a una página libre el tamaño de bloque ``bin`` y enlaza los
+      Asigna a una página libre el tamaño de bloque ``bin`` y enlaza los

       nuevos bloques libres a la lista de libres correspondiente (análogo
       a ``assign_page()``).
 
       nuevos bloques libres a la lista de libres correspondiente (análogo
       a ``assign_page()``).
 


@@ -1274,14 +1266,14 @@ Asignación de memoria
       a ``find_pages(n)``).
 
    *malloc(size, bits)*
       a ``find_pages(n)``).
 
    *malloc(size, bits)*

-      asigna memoria para un objeto de tamaño ``size`` bytes. Análoga al
+      Asigna memoria para un objeto de tamaño ``size`` bytes. Análoga al

       algoritmo ``new(size, attr)`` presentado, excepto que introduce además
       un caché para no recalcular el tamaño de bloque necesario si se realizan
       múltiples asignaciones consecutivas de objetos del mismo tamaño y que la
       asignación de objetos pequeños no está separada en una función aparte.
 
    *bigAlloc(size)*
       algoritmo ``new(size, attr)`` presentado, excepto que introduce además
       un caché para no recalcular el tamaño de bloque necesario si se realizan
       múltiples asignaciones consecutivas de objetos del mismo tamaño y que la
       asignación de objetos pequeños no está separada en una función aparte.
 
    *bigAlloc(size)*

-      asigna un objeto grande (análogo a ``new_big()``). La implementación es
+      Asigna un objeto grande (análogo a ``new_big()``). La implementación es

       mucho más compleja que la presentada en ``new_big()``, pero la semántica
       es la misma. La única diferencia es que esta función aprovecha que
       ``fullcollectshell()`` / ``fullcollect()`` retornan la cantidad de
       mucho más compleja que la presentada en ``new_big()``, pero la semántica
       es la misma. La única diferencia es que esta función aprovecha que
       ``fullcollectshell()`` / ``fullcollect()`` retornan la cantidad de


@@ -1290,7 +1282,7 @@ Asignación de memoria
       objeto grande y pasar directamente a crear un nuevo *pool*.
 
    *free(p)*
       objeto grande y pasar directamente a crear un nuevo *pool*.
 
    *free(p)*

-      libera la memoria apuntada por ``p`` (análoga a ``delete()`` de la
+      Libera la memoria apuntada por ``p`` (análoga a ``delete()`` de la

       sección anterior).
 
    Recordar que la ``pooltable`` siempre se mantiene ordenada según la
       sección anterior).
 
    Recordar que la ``pooltable`` siempre se mantiene ordenada según la


@@ -1298,11 +1290,11 @@ Asignación de memoria
 
 Recolección
    *mark(pbot, ptop)*
 
 Recolección
    *mark(pbot, ptop)*

-      marca un rango de memoria. Este método es análogo al ``mark_range()``
+      Marca un rango de memoria. Este método es análogo al ``mark_range()``

       presentado en la sección :ref:`dgc_algo_mark`.
 
    *fullcollectshell()*
       presentado en la sección :ref:`dgc_algo_mark`.
 
    *fullcollectshell()*

-      guarda los registros en el *stack* y llama a ``fullcollect()``. El
+      Guarda los registros en el *stack* y llama a ``fullcollect()``. El

       algoritmo presentado en :ref:`dgc_algo_mark` es simbólico, ya que si los
       registros se apilaran en el *stack* dentro de otra función, al salir de
       esta se volverían a des-apilar, por lo tanto debe ser hecho en la misma
       algoritmo presentado en :ref:`dgc_algo_mark` es simbólico, ya que si los
       registros se apilaran en el *stack* dentro de otra función, al salir de
       esta se volverían a des-apilar, por lo tanto debe ser hecho en la misma


@@ -1310,7 +1302,7 @@ Recolección
       caso).
 
    *fullcollect(stackTop)*
       caso).
 
    *fullcollect(stackTop)*

-      realiza la recolección de basura. Es análoga a ``collect()`` pero es
+      Realiza la recolección de basura. Es análoga a ``collect()`` pero es

       considerablemente menos modular, todos los pasos se hacen directamente
       en esta función: marcado del *root set*, marcado iterativo del *heap*,
       barrido y reconstrucción de la lista de libres. Además devuelve la
       considerablemente menos modular, todos los pasos se hacen directamente
       en esta función: marcado del *root set*, marcado iterativo del *heap*,
       barrido y reconstrucción de la lista de libres. Además devuelve la


@@ -1480,9 +1472,9 @@ Las opciones más importantes son:
    bits estén intactas. Esto permite detectar de forma temprana errores tanto
    en el recolector como en el programa del usuario.
 
    bits estén intactas. Esto permite detectar de forma temprana errores tanto
    en el recolector como en el programa del usuario.
 

-   .. fig:: fig:sentinel
+   .. flt:: fig:sentinel

 
 

-      Esquema de un bloque cuando está activada la opción ``SENTINEL``.
+      Esquema de un bloque cuando está activada la opción ``SENTINEL``

 
       .. aafig::
          :textual:
 
       .. aafig::
          :textual:


@@ -1533,6 +1525,8 @@ recolector actual y en consecuencia sea muy complicado escribir documentación
 o mejorarlo. Esto a su vez provoca que, al no disponer de una implementación
 de referencia sencilla, sea muy difícil implementar un recolector nuevo.
 
 o mejorarlo. Esto a su vez provoca que, al no disponer de una implementación
 de referencia sencilla, sea muy difícil implementar un recolector nuevo.
 

+.. highlight:: d
+

 Este es, probablemente, la raíz de todos los demás problemas del recolector
 actual. Para ilustrar la dimensión del problema se presenta la implementación
 real de la función ``bigAlloc()``::
 Este es, probablemente, la raíz de todos los demás problemas del recolector
 actual. Para ilustrar la dimensión del problema se presenta la implementación
 real de la función ``bigAlloc()``::


@@ -1654,7 +1648,7 @@ esporádicamente [NGD54084]_ [NGL13744]_.
 De todas maneras queda mucho lugar para mejoras, y es un tema recurrente en el
 grupo de noticias de D_ y se han discutido formas de poder hacer que, al menos
 el *heap* sea preciso [NGD44607]_ [NGD29291]_. Además se mostró un interés
 De todas maneras queda mucho lugar para mejoras, y es un tema recurrente en el
 grupo de noticias de D_ y se han discutido formas de poder hacer que, al menos
 el *heap* sea preciso [NGD44607]_ [NGD29291]_. Además se mostró un interés

-general por tener un recolector más preciso [NGDN87831]_, pero no han habido
+general por tener un recolector más preciso [NGD87831]_, pero no han habido

 avances al respecto.
 
 Otra forma de minimizar los efectos de la falta de precisión que se ha
 avances al respecto.
 
 Otra forma de minimizar los efectos de la falta de precisión que se ha


@@ -1692,27 +1686,27 @@ sincronización excesivo.
 
 Se ha sugerido en el pasado el uso de *pools* y listas de libres específicos
 de hilos, de manera de disminuir la contención, al menos para la asignación de
 
 Se ha sugerido en el pasado el uso de *pools* y listas de libres específicos
 de hilos, de manera de disminuir la contención, al menos para la asignación de

-memoria [NGD75952]_ [NGDN87831]_.
+memoria [NGD75952]_ [NGD87831]_.

 
 Además se ha mostrado un interés por tener un nivel de concurrencia aún mayor
 en el recolector, para aumentar la concurrencia en ambientes *multi-core* en
 general pero en particular para evitar grandes pausas en programas con
 requerimientos de tiempo real, históricamente una de las principales críticas
 
 Además se ha mostrado un interés por tener un nivel de concurrencia aún mayor
 en el recolector, para aumentar la concurrencia en ambientes *multi-core* en
 general pero en particular para evitar grandes pausas en programas con
 requerimientos de tiempo real, históricamente una de las principales críticas

-al lenguaje [NGDN87831]_ [NGL3937]_ [NGD22968]_ [NGA15246]_ [NGD5622]_
+al lenguaje [NGD87831]_ [NGL3937]_ [NGD22968]_ [NGA15246]_ [NGD5622]_

 [NGD2547]_ [NGD18354]_.
 
 
 Finalización
 ^^^^^^^^^^^^
 El recolector actual no garantiza la finalización de objetos. En particular
 [NGD2547]_ [NGD18354]_.
 
 
 Finalización
 ^^^^^^^^^^^^
 El recolector actual no garantiza la finalización de objetos. En particular

-los objetos no son finalizados (es decir, no se llama a sus destructores)
-si aún alcanzables desde el *root set* cuando el programa termina. Cabe
-destacar que esto puede darse porque hay una referencia real desde el *root
-set* (en cuyo caso queda bajo el control del usuario) pero también, dado que
-el *root set* se visita de forma conservativa, se puede deber a un falso
-positivo, en cuyo caso la omisión de la finalización queda por completo fuera
-del control del usuario (y lo que es aún peor, el usuario no puede ser
-siquiera notificado de esta anomalía).
+los objetos no son finalizados (es decir, no se llama a sus destructores) si
+aún alcanzables desde el *root set* cuando el programa termina. Cabe destacar
+que esto puede darse porque hay una referencia real desde el *root set* (en
+cuyo caso queda bajo el control del usuario) pero también, dado que el *root
+set* se visita de forma conservativa, se puede deber a un *falso positivo*, en
+cuyo caso la omisión de la finalización queda por completo fuera del control
+del usuario (y lo que es aún peor, el usuario no puede ser siquiera notificado
+de esta anomalía).

 
 Si bien la especificación de D_ no requiere esta capacidad (de hecho,
 rigurosamente hablando la especificación de D_ no garantiza la finalización de
 
 Si bien la especificación de D_ no requiere esta capacidad (de hecho,
 rigurosamente hablando la especificación de D_ no garantiza la finalización de


@@ -1782,13 +1776,13 @@ Finalmente hay varios detalles en la implementación actual que podrían
 mejorarse:
 
 Listas de libres
 mejorarse:
 
 Listas de libres

-   hay 12 listas de libres, como para guardar bloques de tamaño de ``B_16``
+   Hay 12 listas de libres, como para guardar bloques de tamaño de ``B_16``

    a ``B_2048``, ``B_PAGE``, ``B_PAGEPLUS``, ``B_UNCOMMITTED`` y ``B_FREE``;
    sin embargo solo tienen sentido los bloques de tamaño ``B_16``
    a ``B_2048``, por lo que 4 de esas listas no se utilizan.
 
 Conjuntos de bits para indicadores
    a ``B_2048``, ``B_PAGE``, ``B_PAGEPLUS``, ``B_UNCOMMITTED`` y ``B_FREE``;
    sin embargo solo tienen sentido los bloques de tamaño ``B_16``
    a ``B_2048``, por lo que 4 de esas listas no se utilizan.
 
 Conjuntos de bits para indicadores

-   los indicadores para la fase de marcado y otras propiedades de un bloque
+   Los indicadores para la fase de marcado y otras propiedades de un bloque

    son almacenados en conjuntos de bits que almacenan los indicadores de todos
    los bloques de un *pool*. Si bien se ha mencionado esto como una ventaja,
    hay lugar todavía como para algunas mejoras. Como un *pool* tiene páginas
    son almacenados en conjuntos de bits que almacenan los indicadores de todos
    los bloques de un *pool*. Si bien se ha mencionado esto como una ventaja,
    hay lugar todavía como para algunas mejoras. Como un *pool* tiene páginas


@@ -1810,26 +1804,20 @@ Repetición de código
    actualmente). Esto es propenso a errores y difícil de mantener.
 
 Uso de señales
    actualmente). Esto es propenso a errores y difícil de mantener.
 
 Uso de señales

-   el recolector actual utiliza las señales del sistema operativo ``SIGUSR1``
+   El recolector actual utiliza las señales del sistema operativo ``SIGUSR1``

    y ``SIGUSR2`` para pausar y reanudar los hilos respectivamente. Esto
    puede traer inconvenientes a usuarios que desean utilizar estas
    señales en sus programas (o peor aún, si interactúan con bibliotecas
    de C que hacen uso de estas señales) [NGD5821]_.
 
 Marcado iterativo
    y ``SIGUSR2`` para pausar y reanudar los hilos respectivamente. Esto
    puede traer inconvenientes a usuarios que desean utilizar estas
    señales en sus programas (o peor aún, si interactúan con bibliotecas
    de C que hacen uso de estas señales) [NGD5821]_.
 
 Marcado iterativo

-   si bien esto se mencionó como algo bueno del recolector actual, es un
+   Si bien esto se mencionó como algo bueno del recolector actual, es un

    compromiso entre tiempo y espacio, y puede ser interesante analizar otros
    métodos para evitar la recursión que no requieran tantas pasadas sobre el
    *heap*.
 
 
 
    compromiso entre tiempo y espacio, y puede ser interesante analizar otros
    métodos para evitar la recursión que no requieran tantas pasadas sobre el
    *heap*.
 
 
 

-.. Esto sería muy similar a la sección de "Recolección de basura) pero en
-   vez de ir describiendo los algoritmos iría comentando por qué los tomo
-   o descarto
-   ESTADO: INCOMPLETO
-
-

 .. _dgc_via:
 
 Análisis de viabilidad
 .. _dgc_via:
 
 Análisis de viabilidad


@@ -1915,8 +1903,8 @@ base del algoritmo del recolector de basura actual.
 En general en la comunidad de D_ no hay mayores críticas al marcado y barrido
 en sí, si no más bien a problemas asociados a la implementación actual,
 principalmente a las grandes pausas o la falta de :ref:`precisión
 En general en la comunidad de D_ no hay mayores críticas al marcado y barrido
 en sí, si no más bien a problemas asociados a la implementación actual,
 principalmente a las grandes pausas o la falta de :ref:`precisión

-<gc_conserv>` [NGD54084]_ [NGL13744]_ [NGD44607]_ [NGD29291]_ [NGDN87831]_
-[NGDN87831]_ [NGL3937]_ [NGD22968]_ [NGA15246]_ [NGD5622]_ [NGD2547]_
+<gc_conserv>` [NGD54084]_ [NGL13744]_ [NGD44607]_ [NGD29291]_ [NGD87831]_
+[NGD87831]_ [NGL3937]_ [NGD22968]_ [NGA15246]_ [NGD5622]_ [NGD2547]_

 [NGD18354]_.
 
 Esta familia de algoritmos se adapta bien a los requerimientos principales de
 [NGD18354]_.
 
 Esta familia de algoritmos se adapta bien a los requerimientos principales de


@@ -1935,7 +1923,7 @@ Una de las principales mejoras que pueden realizarse es hacer al recolector
 :ref:`concurrente <gc_concurrent>` y parcialmente más :ref:`preciso
 <gc_conserv>`. Estas dos mejoras solamente alcanzarían para mejorar de forma
 notable el tiempo de pausa en las recolecciones y la cantidad de memoria
 :ref:`concurrente <gc_concurrent>` y parcialmente más :ref:`preciso
 <gc_conserv>`. Estas dos mejoras solamente alcanzarían para mejorar de forma
 notable el tiempo de pausa en las recolecciones y la cantidad de memoria

-retenida debido a falsos positivos.
+retenida debido a *falsos positivos*.

 
 Más adelante veremos detalles sobre algunos de estos aspectos y sobre algunos
 algoritmos particulares que permiten hacer concurrente al recolector actual.
 
 Más adelante veremos detalles sobre algunos de estos aspectos y sobre algunos
 algoritmos particulares que permiten hacer concurrente al recolector actual.