Completar capítulo de Solución adoptada

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

diff --git a/source/dgc.rst b/source/dgc.rst
index a457444c2ebe0d90bd3a352eb294307a02e48708..804d554aae4c6ff22226c0a55a2b08622ee8db2a 100644 (file)
--- a/source/dgc.rst
+++ b/source/dgc.rst
@@ -4,7 +4,7 @@
    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).
    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
+   ESTADO: TERMINADO, CORREGIDO

 
 
 .. _dgc:
 
 
 .. _dgc:


@@ -49,7 +49,7 @@ Sin dudas las características de D_ que lo hacen más complejo a la hora de
 implementar un recolector de basura son sus capacidades de programación de
 bajo nivel (ver :ref:`d_low_level`).
 
 implementar un recolector de basura son sus capacidades de programación de
 bajo nivel (ver :ref:`d_low_level`).
 

-Al proveer acceso a *aasembly*, permitir estructuras de tipo *union* y ser
+Al proveer acceso a *assembly*, permitir estructuras de tipo *union* y ser

 compatible con C/C++, el recolector de basura tiene muchas restricciones. Por
 ejemplo debe tratar de forma conservativa los registros y el *stack*, ya que
 es la única forma de interactuar de forma segura con C/C++ y *assembly*.
 compatible con C/C++, el recolector de basura tiene muchas restricciones. Por
 ejemplo debe tratar de forma conservativa los registros y el *stack*, ya que
 es la única forma de interactuar de forma segura con C/C++ y *assembly*.


@@ -63,8 +63,8 @@ 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 la
-eficiencia por el exceso de posibles punteros a revisar, además de lo
+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
 estructura no alineada al tamaño de palabra.
 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
 estructura no alineada al tamaño de palabra.


@@ -127,7 +127,7 @@ Orientación a objetos y finalización
 D_ soporta el paradigma de orientación a objetos, donde es común permitir que
 un objeto, al ser destruido, realice alguna tarea de finalización (a través de
 una función miembro llamada *destructor*, o ``~this()`` en D_). Esto significa
 D_ soporta el paradigma de orientación a objetos, donde es común permitir que
 un objeto, al ser destruido, realice alguna tarea de finalización (a través de
 una función miembro llamada *destructor*, o ``~this()`` en D_). Esto significa

-que el recolector, al encontrar que un objeto no es más referenciados, debe
+que el recolector, al encontrar que no hay más referencias a un objeto, debe

 ejecutar el destructor.
 
 La especificación dice:
 ejecutar el destructor.
 
 La especificación dice:


@@ -149,7 +149,7 @@ a otros objetos en un destructor.
 
 Esta restricción en realidad se ve relaja con el soporte de *RAII*. Si se
 utiliza la palabra clave ``scope`` al crear una serie de objetos, estos serán
 
 Esta restricción en realidad se ve relaja con el soporte de *RAII*. Si se
 utiliza la palabra clave ``scope`` al crear una serie de objetos, estos serán

-destruídos determinísticamente al finalizar el *scope* actual en el orden
+destruidos determinísticamente al finalizar el *scope* actual en el orden

 inverso al que fueron creados y, por lo tanto, un usuario podría hacer uso de
 los atributos que sean referencias a otros objetos creados con ``scope`` si el
 orden en que fueron creados (y por lo tanto en que serán destruidos) se lo
 inverso al que fueron creados y, por lo tanto, un usuario podría hacer uso de
 los atributos que sean referencias a otros objetos creados con ``scope`` si el
 orden en que fueron creados (y por lo tanto en que serán destruidos) se lo


@@ -182,7 +182,7 @@ formas de mejorarlo.
 Como se mencionó en la sección :ref:`d_lang`, en D_ hay dos bibliotecas base
 para soportar el lenguaje (*runtimes*): Phobos_ y Tango_. La primera es la
 biblioteca estándar de D_, la segunda un proyecto más abierto y dinámico que
 Como se mencionó en la sección :ref:`d_lang`, en D_ hay dos bibliotecas base
 para soportar el lenguaje (*runtimes*): Phobos_ y Tango_. La primera es la
 biblioteca estándar de D_, la segunda un proyecto más abierto y dinámico que

-surgió como alternativa a Phobos_ debido a que Phobos_ es muy desprolija y que
+surgió como alternativa a Phobos_ debido a que Phobos_ es muy descuidada y que

 era muy difícil impulsar cambios en ella. Ahora Phobos_ tiene el agravante de
 estar *congelada* en su versión 1 (solo se realizan correcciones de errores).
 
 era muy difícil impulsar cambios en ella. Ahora Phobos_ tiene el agravante de
 estar *congelada* en su versión 1 (solo se realizan correcciones de errores).
 


@@ -220,7 +220,7 @@ Organización del *heap*
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 La memoria del *heap* está organizada en *pools*. Un *pool* es una región de
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 La memoria del *heap* está organizada en *pools*. Un *pool* es una región de

-*páginas* contíguas. Una página es, en general, la unidad mínima de memoria que
+*páginas* contiguas. Una página es, en general, la unidad mínima de memoria que

 maneja un sistema operativo con soporte de memoria virtual. Cada página dentro
 de un *pool* sirve a su vez como contenedora de bloques (llamados *bin* en la
 :ref:`implementación <dgc_impl>`) de tamaño fijo. Todos los bloques
 maneja un sistema operativo con soporte de memoria virtual. Cada página dentro
 de un *pool* sirve a su vez como contenedora de bloques (llamados *bin* en la
 :ref:`implementación <dgc_impl>`) de tamaño fijo. Todos los bloques


@@ -231,7 +231,7 @@ pertenecientes a la misma página tienen el mismo tamaño de bloque (ver figura
 o celdas en general se ubican en estos bloques (en uno del tamaño más pequeño
 que haya que sea suficientemente grande como para almacenar dicho objeto).  En
 caso de que un objeto sea mayor a una página, se utilizan la menor cantidad de
 o celdas en general se ubican en estos bloques (en uno del tamaño más pequeño
 que haya que sea suficientemente grande como para almacenar dicho objeto).  En
 caso de que un objeto sea mayor a una página, se utilizan la menor cantidad de

-páginas contíguas de un pool que tengan espacio suficiente para almacenar
+páginas contiguas de un pool que tengan espacio suficiente para almacenar

 dicho objeto.
 
 .. [#dgcpageplus] Además existe otro tamaño de bloque especial que se utiliza
 dicho objeto.
 
 .. [#dgcpageplus] Además existe otro tamaño de bloque especial que se utiliza


@@ -248,7 +248,7 @@ dicho objeto.
    páginas del *pool* N) que es una página completa.
 
    .. aafig::
    páginas del *pool* N) que es una página completa.
 
    .. aafig::

-      :scale: 1.4
+      :scale: 120

 
       +----------------------------------------------------------------------+
       |                                 Heap                                 |
 
       +----------------------------------------------------------------------+
       |                                 Heap                                 |


@@ -337,12 +337,12 @@ Atributos de *pool*
 ^^^^^^^^^^^^^^^^^^^
 Cada *pool* tiene la siguiente información asociada:
 
 ^^^^^^^^^^^^^^^^^^^
 Cada *pool* tiene la siguiente información asociada:
 

-*number_of_pages*:
+*number_of_pages*

    cantidad de páginas que tiene. Esta cantidad es fija en toda la vida de un
    *pool*.
 
    cantidad de páginas que tiene. Esta cantidad es fija en toda la vida de un
    *pool*.
 

-*pages*:
-   bloque de memoria contíguo de tamaño ``PAGE_SIZE * number_of_pages``
+*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).
 
 


@@ -353,16 +353,16 @@ Se trata del tamaño de los bloques que almacena esta página.
 
 Una página siempre almacena bloques del mismo tamaño, que pueden ser 16, 32,
 64, 128, 256, 512, 1024, 2048 o 4096 (llamado con el nombre especial
 
 Una página siempre almacena bloques del mismo tamaño, que pueden ser 16, 32,
 64, 128, 256, 512, 1024, 2048 o 4096 (llamado con el nombre especial

-``PAGE``). Además hay dos tamaños de bloque símbólicos que tienen un
+``PAGE``). Además hay dos tamaños de bloque simbólicos que tienen un

 significado especial:
 
 significado especial:
 

-``FREE``:
+``FREE``

    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).
 
    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``:
+``CONTINUATION``

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


@@ -375,28 +375,28 @@ Atributos de bloque
 ^^^^^^^^^^^^^^^^^^^
 Cada bloque tiene asociados varios atributos:
 
 ^^^^^^^^^^^^^^^^^^^
 Cada bloque tiene asociados varios atributos:
 

-*mark*:
+*mark*

    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>`).
 
    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*:
+*scan*

    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>`).
 
    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*:
+*free*

    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*).
 
    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*:
+*final*

    indica que el bloque contiene un objeto que tiene un destructor (que debe
    ser llamado cuando la celda pasa de *viva* a *basura*).
 
    indica que el bloque contiene un objeto que tiene un destructor (que debe
    ser llamado cuando la celda pasa de *viva* a *basura*).
 

-*noscan*:
+*noscan*

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


@@ -405,7 +405,7 @@ Objetos grandes
 ^^^^^^^^^^^^^^^
 El recolector de basura actual de D_ trata de forma diferente a los objetos
 grandes. Todo objeto grande empieza en un bloque con tamaño ``PAGE``
 ^^^^^^^^^^^^^^^
 El recolector de basura actual de D_ trata de forma diferente a los objetos
 grandes. Todo objeto grande empieza en un bloque con tamaño ``PAGE``

-y (opcionalmente) continúa en los bloques contíguos subsiguientes que tengan
+y (opcionalmente) continúa en los bloques contiguos subsiguientes que tengan

 el tamaño de bloque ``CONTINUATION`` (si el objeto ocupa más que una página).
 El fin de un objeto grande queda marcado por el fin del *pool* o una página
 con tamaño de bloque distinto a ``CONTINUATION`` (lo que suceda primero).
 el tamaño de bloque ``CONTINUATION`` (si el objeto ocupa más que una página).
 El fin de un objeto grande queda marcado por el fin del *pool* o una página
 con tamaño de bloque distinto a ``CONTINUATION`` (lo que suceda primero).


@@ -439,7 +439,7 @@ organización del *heap* que se explicó en la sección anterior.
 
 Recolección
 ^^^^^^^^^^^
 
 Recolección
 ^^^^^^^^^^^

-A grandes razgos el algoritmo de recolección puede resumirse de las dos fases
+A grandes rasgos el algoritmo de recolección puede resumirse de las dos fases

 básicas de cualquier algoritmo de :ref:`marcado y barrido <gc_mark_sweep>`::
 
    function collect() is
 básicas de cualquier algoritmo de :ref:`marcado y barrido <gc_mark_sweep>`::
 
    function collect() is


@@ -455,34 +455,45 @@ Esta fase consiste de varios pasos, que pueden resumirse en el siguiente
 algoritmo::
 
    function mark_phase() is
 algoritmo::
 
    function mark_phase() is

-      more_to_scan = false
+      global more_to_scan = false

       stop_the_world()
       clear_mark_scan_bits()
       mark_free_lists()
       mark_static_data()
       push_registers_into_stack()
       stop_the_world()
       clear_mark_scan_bits()
       mark_free_lists()
       mark_static_data()
       push_registers_into_stack()

+      thread_self.stack.end = get_stack_top()

       mark_stacks()
       mark_stacks()

+      pop_registers_from_stack()

       mark_user_roots()
       mark_heap()
       start_the_world()
 
 La variable **global** ``more_to_scan`` indica al algoritmo iterativo cuando
       mark_user_roots()
       mark_heap()
       start_the_world()
 
 La variable **global** ``more_to_scan`` indica al algoritmo iterativo cuando

-debe finalizar: la función ``mark()`` (que veremos más adelante) lo pone en
-``true`` cuando una nueva celda debe ser visitada, por lo tanto la iteración
-se interrumpe cuando no hay más celdas por visitar.
+debe finalizar: la función ``mark_range()`` (que veremos más adelante) lo pone
+en ``true`` cuando una nueva celda debe ser visitada, por lo tanto la
+iteración se interrumpe cuando no hay más celdas por visitar.

 
 

-Las funciones ``stop_the_world()`` y ``start_the_world()`` sencillamente
-pausan y reanudan todos los hilos respectivamente::
+Las funciones ``stop_the_world()`` y ``start_the_world()`` pausan y reanudan
+todos los hilos respectivamente (salvo el actual). Al pausar los hilos además
+se guardan los registros del procesador en el *stack* y se guarda la posición
+actual del *stack* para que la fase de marcado pueda recorrerlos::

 
    function stop_the_world() is
       foreach thread in threads
 
    function stop_the_world() is
       foreach thread in threads

+         if thread is thread_self
+            continue

          thread.pause()
          thread.pause()

+         push_registers_into_stack()
+         thread.stack.end = get_stack_top()

 
    function start_the_world() is
       foreach thread in threads
 
    function start_the_world() is
       foreach thread in threads

+         if thread is thread_self
+            continue
+         pop_registers_from_stack()

          thread.resume()
 
          thread.resume()
 

-La función ``clear_mark_scan_bits()`` se encarga de resetear todos los
+La función ``clear_mark_scan_bits()`` se encarga de restablecer todos los

 atributos *mark* y *scan* de cada bloque del *heap*::
 
    function clear_mark_scan_bits() is
 atributos *mark* y *scan* de cada bloque del *heap*::
 
    function clear_mark_scan_bits() is


@@ -497,7 +508,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

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


@@ -517,9 +528,7 @@ Primero se marca el área de memoria estática de manera :ref:`conservativa
 <gc_conserv>` (es decir, tomando cada *word* como si fuera un puntero)::
 
    function mark_static_data() is
 <gc_conserv>` (es decir, tomando cada *word* como si fuera un puntero)::
 
    function mark_static_data() is

-      foreach word in static_data
-         pointer = cast(void*) word
-         mark(pointer)
+      mark_range(static_data.begin, static_data.end)

 
 Para poder tomar los registros como parte del *root set* primero se apilan
 en el *stack* a través de la función::
 
 Para poder tomar los registros como parte del *root set* primero se apilan
 en el *stack* a través de la función::


@@ -528,38 +537,46 @@ en el *stack* a través de la función::
       foreach register in registers
          push(register)
 
       foreach register in registers
          push(register)
 

+Y luego se descartan (no es necesario ni correcto restablecer los valores ya
+que podrían tener nuevos valores) al sacarlos de la pila::
+
+   function pop_registers_from_stack() is
+      foreach register in reverse(registers)
+         pop()
+

 Una vez hecho esto, basta marcar (de forma conservativa) los *stacks* de todos
 los threads para terminar de marcar el *root set*::
 
    function mark_stacks() is
       foreach thread in threads
 Una vez hecho esto, basta marcar (de forma conservativa) los *stacks* de todos
 los threads para terminar de marcar el *root set*::
 
    function mark_stacks() is
       foreach thread in threads

-         foreach word in thread.stack
-            pointer = cast(void*) word
-            mark(pointer)
+         mark_range(thread.stack.begin, thread.stack.end)

 
 Dado que D_ soporta manejo de memoria manual al mismo tiempo que memoria
 automática, es posible que existan celdas de memoria que no estén en el *root
 set* convencional ni en el *heap* del recolector. Para evitar que se libere
 
 Dado que D_ soporta manejo de memoria manual al mismo tiempo que memoria
 automática, es posible que existan celdas de memoria que no estén en el *root
 set* convencional ni en el *heap* del recolector. Para evitar que se libere

-alguna celda que estaba siendo referenciada desde memoria administrada por el
-usuario, éste debe informarle al recolector sobre la existencia de estoas
-nuevas raíces. Es por esto que para concluir el marcado del *root set*
+alguna celda a la cual todavía existen referencias desde memoria administrada
+por el usuario, éste debe informarle al recolector sobre la existencia de
+estas nuevas raíces. Es por esto que para concluir el marcado del *root set*

 completo se procede a marcar las raíces definidas por el usuario::
 
    function mark_user_roots() is
 completo se procede a marcar las raíces definidas por el usuario::
 
    function mark_user_roots() is

-      foreach pointer in user_roots
-         mark(pointer)
+      foreach root_range in user_roots
+         mark_range(root_range.begin, root_range.end)

 
 El algoritmo de marcado no es recursivo sino iterativo por lo tanto al marcar
 una celda (o bloque) no se siguen sus *hijas*, solo se activa el bit de *scan*
 (a menos que la celda no contenga punteros, es decir, tenga el bit *noscan*)::
 
 
 El algoritmo de marcado no es recursivo sino iterativo por lo tanto al marcar
 una celda (o bloque) no se siguen sus *hijas*, solo se activa el bit de *scan*
 (a menos que la celda no contenga punteros, es decir, tenga el bit *noscan*)::
 

-   function mark(pointer) is
-      [pool, page, block] = find_block(pointer)
-      if block is not null and block.mark is false
-         block.mark = true
-         if block.noscan is false
-            block.scan = true
-            more_to_scan = true
+   function mark_range(begin, end) is
+      pointer = begin
+      while pointer < end
+         [pool, page, block] = find_block(pointer)
+         if block is not null and block.mark is false
+            block.mark = true
+            if block.noscan is false
+               block.scan = true
+               global more_to_scan = true
+         pointer++

 
 Por lo tanto en este punto, tenemos todas las celdas inmediatamente
 alcanzables desde el *root set* marcadas y con el bit *scan* activado si la
 
 Por lo tanto en este punto, tenemos todas las celdas inmediatamente
 alcanzables desde el *root set* marcadas y con el bit *scan* activado si la


@@ -568,8 +585,8 @@ forma conservativa) iterativamente todo el *heap* hasta que no hayan más
 celdas para visitar (con el bit *scan* activo)::
 
    function mark_heap() is
 celdas para visitar (con el bit *scan* activo)::
 
    function mark_heap() is

-      while more_to_scan
-         more_to_scan = false
+      while global more_to_scan
+         global more_to_scan = false

          foreach pool in heap
             foreach page in pool
                if page.block_size <= PAGE // saltea FREE y CONTINUATION
          foreach pool in heap
             foreach page in pool
                if page.block_size <= PAGE // saltea FREE y CONTINUATION


@@ -577,23 +594,19 @@ celdas para visitar (con el bit *scan* activo)::
                      if block.scan is true
                         block.scan = false
                         if page.block_size is PAGE // objeto grande
                      if block.scan is true
                         block.scan = false
                         if page.block_size is PAGE // objeto grande

-                           start = cast(byte*) page
+                           begin = cast(byte*) page

                            end = find_big_object_end(pool, page)
                            end = find_big_object_end(pool, page)

-                           foreach word in start..end
-                                 pointer = cast(void*) word
-                                 mark(pointer)
+                           mark_range(begin, end)

                         else // objeto pequeño
                         else // objeto pequeño

-                           foreach word in block
-                              pointer = cast(void*) word
-                              mark(pointer)
+                           mark_range(block.begin, block.end)

 
 Aquí puede verse, con un poco de esfuerzo, la utilización de la
 
 Aquí puede verse, con un poco de esfuerzo, la utilización de la

-:ref:`abtracción tricolor <gc_intro_tricolor>`: todas las celdas alcanzables
+:ref:`abstracción tricolor <gc_intro_tricolor>`: todas las celdas alcanzables

 desde el *root set* son pintadas de *gris* (tienen los bits *mark* y *scan*
 activados), excepto aquellas celdas atómicas (es decir, que se sabe que no
 tienen punteros) que son marcadas directamente de *negro*. Luego se van
 obteniendo celdas del conjunto de las *grises*, se las pinta de *negro* (es
 desde el *root set* son pintadas de *gris* (tienen los bits *mark* y *scan*
 activados), excepto aquellas celdas atómicas (es decir, que se sabe que no
 tienen punteros) que son marcadas directamente de *negro*. Luego se van
 obteniendo celdas del conjunto de las *grises*, se las pinta de *negro* (es

-decir, se desactiva el big *scan*) y se pintan todas sus *hijas* de *gris* (o
+decir, se desactiva el bit *scan*) y se pintan todas sus *hijas* de *gris* (o

 *negro* directamente si no tienen punteros). Este procedimiento se repite
 mientras el conjunto de celdas *grises* no sea vacío (es decir, que
 ``more_to_scan`` sea ``true``).
 *negro* directamente si no tienen punteros). Este procedimiento se repite
 mientras el conjunto de celdas *grises* no sea vacío (es decir, que
 ``more_to_scan`` sea ``true``).


@@ -624,8 +637,8 @@ utilizadas en la fase de marcado::
                      return [pool, page, block_start]
       return [null, null, null]
 
                      return [pool, page, block_start]
       return [null, null, null]
 

-Cabe destacar que la función ``find_block()`` devuelve el pool, la página y el
-comienzo del bloque al que apunta el puntero, es decir, soporta punteros
+Cabe destacar que la función ``find_block()`` devuelve el *pool*, la página
+y el comienzo del bloque al que apunta el puntero, es decir, soporta punteros

 *interiores*.
 
 
 *interiores*.
 
 


@@ -665,9 +678,9 @@ objetos grandes se marcan todas las páginas que utilizaban como ``FREE``::
    function free_big_object(pool, page) is
       pool_end = cast(byte*) pool.pages + (PAGE_SIZE * pool.number_of_pages)
       do
    function free_big_object(pool, page) is
       pool_end = cast(byte*) pool.pages + (PAGE_SIZE * pool.number_of_pages)
       do

-         page = cast(byte*) page + PAGE_SIZE

          page.block_size = FREE
          page.block_size = FREE

-      while page.block_size is CONTINUATION and page < pool_end
+         page = cast(byte*) page + PAGE_SIZE
+      while page < pool_end and page.block_size is CONTINUATION

 
 Además, los bloques que tienen en atributo ``final`` son finalizados llamando
 a la función ``finalize()``. Esta función es un servicio que provee la
 
 Además, los bloques que tienen en atributo ``final`` son finalizados llamando
 a la función ``finalize()``. Esta función es un servicio que provee la


@@ -695,7 +708,7 @@ grandes de ser necesario)::
 
 Esta reorganización de listas libres además mejoran la localidad de
 referencia y previenen la fragmentación. La localidad de referencia se ve
 
 Esta reorganización de listas libres además mejoran la localidad de
 referencia y previenen la fragmentación. La localidad de referencia se ve

-mojorada debido a que asignaciones de memoria proximas en el tiempo serán
+mejorada debido a que asignaciones de memoria próximas en el tiempo serán

 también próximas en espacio porque pertenecerán a la misma página (al menos si
 las asignaciones son todas del mismo tamaño). La fragmentación se minimiza por
 el mismo efecto, primero se asignarán todos los bloques de la misma página.
 también próximas en espacio porque pertenecerán a la misma página (al menos si
 las asignaciones son todas del mismo tamaño). La fragmentación se minimiza por
 el mismo efecto, primero se asignarán todos los bloques de la misma página.


@@ -720,7 +733,7 @@ recolector actual.
 Asignación de memoria
 ^^^^^^^^^^^^^^^^^^^^^
 La asignación de memoria del recolector es relativamente compleja, excepto
 Asignación de memoria
 ^^^^^^^^^^^^^^^^^^^^^
 La asignación de memoria del recolector es relativamente compleja, excepto

-cuando se asgina un objeto pequeño y ya existe algún bloque con el tamaño
+cuando se asigna un objeto pequeño y ya existe algún bloque con el tamaño

 preciso en la lista de libres. Para el resto de los casos la cantidad de
 trabajo que debe hacer el recolector para asignar la memoria es considerable.
 
 preciso en la lista de libres. Para el resto de los casos la cantidad de
 trabajo que debe hacer el recolector para asignar la memoria es considerable.
 


@@ -744,18 +757,17 @@ La función ``find_block_size()`` sencillamente busca el tamaño de bloque se
 mejor se ajuste al tamaño solicitado (es decir, el bloque más pequeño lo
 suficientemente grande como para poder almacenar el tamaño solicitado). Una
 vez más el algoritmo distingue objetos grandes de pequeños. Los pequeños se
 mejor se ajuste al tamaño solicitado (es decir, el bloque más pequeño lo
 suficientemente grande como para poder almacenar el tamaño solicitado). Una
 vez más el algoritmo distingue objetos grandes de pequeños. Los pequeños se

-asginan de las siguiente manera::
+asignan de las siguiente manera::

 
 

-      function new_small(block_size) is
+   function new_small(block_size) is
+      block = find_block_with_size(block_size)
+      if block is null
+         collect()

          block = find_block_with_size(block_size)
          if block is null
          block = find_block_with_size(block_size)
          if block is null

-            collect()
+            new_pool()

             block = find_block_with_size(block_size)
             block = find_block_with_size(block_size)

-            if block is null
-               new_pool()
-               block = find_block_with_size(block_size)
-               return null
-         return block
+      return block

 
 Se intenta reiteradas veces conseguir un bloque del tamaño correcto libre,
 realizando diferentes acciones si no se tiene éxito. Primero se intenta hacer
 
 Se intenta reiteradas veces conseguir un bloque del tamaño correcto libre,
 realizando diferentes acciones si no se tiene éxito. Primero se intenta hacer


@@ -765,39 +777,41 @@ pidiendo memoria al *low level allocator* (el sistema operativo generalmente).
 
 Para intentar buscar un bloque de memoria libre se realiza lo siguiente::
 
 
 Para intentar buscar un bloque de memoria libre se realiza lo siguiente::
 

-      function find_block_with_size(block_size) is
+   function find_block_with_size(block_size) is
+      block = free_lists[block_size].pop_first()
+      if block is null
+         assign_page(block_size)

          block = free_lists[block_size].pop_first()
          block = free_lists[block_size].pop_first()

-         if block is null
-            assign_page(block_size)
-            block = free_lists[block_size].pop_first()
-         return block
+      return block

 
 Si no se puede obtener un bloque de la lista de libres correspondiente, se
 busca asignar una página libre al tamaño de bloque deseado de forma de
 *alimentar* la lista de libres con dicho tamaño::
 
 
 Si no se puede obtener un bloque de la lista de libres correspondiente, se
 busca asignar una página libre al tamaño de bloque deseado de forma de
 *alimentar* la lista de libres con dicho tamaño::
 

-      function assign_page(block_size) is
-         foreach pool in heap
-            foreach page in pool
-               if page.block_size is FREE
-                  page.block_size = block_size
-                  foreach block in page
-                     free_lists[page.block_size].link(block)
+   function assign_page(block_size) is
+      foreach pool in heap
+         foreach page in pool
+            if page.block_size is FREE
+               page.block_size = block_size
+               foreach block in page
+                  free_lists[page.block_size].link(block)

 
 Cuando todo ello falla, el último recurso consiste en pedir memoria al sistema
 operativo, creando un nuevo *pool*::
 
 
 Cuando todo ello falla, el último recurso consiste en pedir memoria al sistema
 operativo, creando un nuevo *pool*::
 

-      funciones new_pool(number_of_pages = 1) is
-         pool = alloc(pool.sizeof)
-         if pool is null
-            return null
-         pool.number_of_pages = number_of_pages
-         pool.pages = alloc(number_of_pages * PAGE_SIZE)
-         if pool.pages is null
-            free(pool)
-            return null
-         heap.add(pool)
-         return pool
+   function new_pool(number_of_pages = 1) is
+      pool = alloc(pool.sizeof)
+      if pool is null
+         return null
+      pool.number_of_pages = number_of_pages
+      pool.pages = alloc(number_of_pages * PAGE_SIZE)
+      if pool.pages is null
+         free(pool)
+         return null
+      heap.add(pool)
+      foreach page in pool
+         page.block_size = FREE
+      return pool

 
 Se recuerda que la función ``alloc()`` es un :ref:`servicio
 <gc_intro_services>` provisto por el *low level allocator* y en la
 
 Se recuerda que la función ``alloc()`` es un :ref:`servicio
 <gc_intro_services>` provisto por el *low level allocator* y en la


@@ -813,25 +827,25 @@ Si el tamaño de bloque necesario para cumplir con la asignación de memoria es
 de una página, entonces se utiliza otro algoritmo para alocar un objeto
 grande::
 
 de una página, entonces se utiliza otro algoritmo para alocar un objeto
 grande::
 

-      function new_big(size) is
-         number_of_pages = ceil(size / PAGE_SIZE)
+   function new_big(size) is
+      number_of_pages = ceil(size / PAGE_SIZE)
+      pages = find_pages(number_of_pages)
+      if pages is null
+         collect()

          pages = find_pages(number_of_pages)
          if pages is null
          pages = find_pages(number_of_pages)
          if pages is null

-            collect()
-            pages = find_pages(number_of_pages)
-            if pages is null
-               minimize()
-               pool = new_pool(number_of_pages)
-               if pool is null
-                  return null
-               pages = assign_pages(pool, number_of_pages)
-         pages[0].block_size = PAGE
-         foreach page in pages[1..end]
-            page.block_size = CONTINUATION
-         return pages[0]
+            minimize()
+            pool = new_pool(number_of_pages)
+            if pool is null
+               return null
+            pages = assign_pages(pool, number_of_pages)
+      pages[0].block_size = PAGE
+      foreach page in pages[1..end]
+         page.block_size = CONTINUATION
+      return pages[0]

 
 De forma similar a la asignación de objetos pequeños, se intenta encontrar una
 
 De forma similar a la asignación de objetos pequeños, se intenta encontrar una

-serie de páginas contíguas, dentro de un mismo *pool*, suficientes para
+serie de páginas contiguas, dentro de un mismo *pool*, suficientes para

 almacenar el tamaño requerido y si esto falla, se realizan diferentes pasos
 y se vuelve a intentar. Puede observarse que, a diferencia de la asignación de
 objetos pequeños, si luego de la recolección no se pudo encontrar lugar
 almacenar el tamaño requerido y si esto falla, se realizan diferentes pasos
 y se vuelve a intentar. Puede observarse que, a diferencia de la asignación de
 objetos pequeños, si luego de la recolección no se pudo encontrar lugar


@@ -852,36 +866,36 @@ completamente libres::
             heap.remove(pool)
 
 Volviendo a la función ``new_big()``, para hallar una serie de páginas
             heap.remove(pool)
 
 Volviendo a la función ``new_big()``, para hallar una serie de páginas

-contíguas se utiliza el siguiente algoritmo::
+contiguas se utiliza el siguiente algoritmo::

 
 

-      function find_pages(number_of_pages) is
-         foreach pool in heap
-            pages = assign_pages(pool, number_of_pages)
-            if pages
-               return pages
-         return null
+   function find_pages(number_of_pages) is
+      foreach pool in heap
+         pages = assign_pages(pool, number_of_pages)
+         if pages
+            return pages
+      return null

 
 Como se dijo, las páginas deben estar contenidas en un mismo *pool* (para
 
 Como se dijo, las páginas deben estar contenidas en un mismo *pool* (para

-tener la garantía de que sean contíguas), por lo tanto se busca *pool* por
+tener la garantía de que sean contiguas), por lo tanto se busca *pool* por

 *pool* dicha cantidad de páginas libres consecutivas a través del siguiente
 algoritmo::
 
 *pool* dicha cantidad de páginas libres consecutivas a través del siguiente
 algoritmo::
 

-      function assign_pages(pool, number_of_pages) is
-         pages_found = 0
-         first_page = null
-         foreach page in pool
-            if page.block_size is FREE
-               if pages_found is 0
-                  pages_found = 1
-                  first_page = page
-               else
-                  pages_found = pages_found + 1
-               if pages_found is number_of_pages
-                  return [first_page .. page]
+   function assign_pages(pool, number_of_pages) is
+      pages_found = 0
+      first_page = null
+      foreach page in pool
+         if page.block_size is FREE
+            if pages_found is 0
+               pages_found = 1
+               first_page = page

             else
             else

-               pages_found = 0
-               first_page = null
-         return null
+               pages_found = pages_found + 1
+            if pages_found is number_of_pages
+               return [first_page .. page]
+         else
+            pages_found = 0
+            first_page = null
+      return null

 
 Una vez más, cuando todo ello falla (incluso luego de una recolección), se
 intenta alocar un nuevo *pool*, esta vez con una cantidad de páginas
 
 Una vez más, cuando todo ello falla (incluso luego de una recolección), se
 intenta alocar un nuevo *pool*, esta vez con una cantidad de páginas


@@ -894,7 +908,7 @@ propaga hasta la función ``new()`` que lanza una excepción.
 Liberación de memoria
 ^^^^^^^^^^^^^^^^^^^^^
 La liberación de la memoria asignada puede hacerse explícitamente. Esto
 Liberación de memoria
 ^^^^^^^^^^^^^^^^^^^^^
 La liberación de la memoria asignada puede hacerse explícitamente. Esto

-saltéa el mecanismo de recolección, y es utilizado para dar soporte a menejo
+saltea el mecanismo de recolección, y es utilizado para dar soporte a manejo

 explícito de memoria asignada en el *heap* del recolector. En general el
 usuario no debe utilizar liberación explícita, pero puede ser útil en casos
 muy particulares::
 explícito de memoria asignada en el *heap* del recolector. En general el
 usuario no debe utilizar liberación explícita, pero puede ser útil en casos
 muy particulares::


@@ -939,7 +953,7 @@ Detalles de implementación
 Hay varias diferencias a nivel de implementación entre lo que se presentó en
 las secciones anteriores y como está implementado realmente el recolector
 actual. Con los conceptos e ideas principales del ya explicadas, se procede
 Hay varias diferencias a nivel de implementación entre lo que se presentó en
 las secciones anteriores y como está implementado realmente el recolector
 actual. Con los conceptos e ideas principales del ya explicadas, se procede

-a ahondar con más detalle en como está construído el recolector y algunas de
+a ahondar con más detalle en como está construido el recolector y algunas de

 sus optimizaciones principales.
 
 Vale aclarar que el recolector de basura actual está implementado en D_.
 sus optimizaciones principales.
 
 Vale aclarar que el recolector de basura actual está implementado en D_.


@@ -951,22 +965,20 @@ El recolector está principalmente contenido en la estructura llamada ``Gcx``.
 Dicha estructura tiene los siguientes atributos (divididos en categorías para
 facilitar la comprensión):
 
 Dicha estructura tiene los siguientes atributos (divididos en categorías para
 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
       provistas por el usuario.
 
       arreglo variable de punteros simples que son tomados como raíces
       provistas por el usuario.
 

-   *ranges* (*nranges*, *rangedim*):
+   *ranges* (*nranges*, *rangedim*)

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

-**Estado interno del recolector**
-
-   *anychanges*:
+Estado interno del recolector
+   *anychanges*

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


@@ -974,54 +986,52 @@ facilitar la comprensión):
       <gc_intro_tricolor>`). Es análoga a la variable ``more_to_scan``
       presentada en :ref:`dgc_algo_mark`.
 
       <gc_intro_tricolor>`). Es análoga a la variable ``more_to_scan``
       presentada en :ref:`dgc_algo_mark`.
 

-   *inited*:
+   *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).
       Se utiliza para saber por donde comenzar a visitar el *stack* de forma
       conservativa, tomándolo con una raíz del recolector.
 
       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*):
+   *Pools* (*pooltable*, *npools*)

       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.
 
       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*:
+   *bucket*

       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).
 
       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*:
+Atributos que cambian el comportamiento
+   *noStack*

       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.
 
       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*:
+   *log*

       indica si se debe guardar un registro de la actividad del recolector. Es
       utilizado principalmente para depuración.
 
       indica si se debe guardar un registro de la actividad del recolector. Es
       utilizado principalmente para depuración.
 

-   *disabled*:
+   *disabled*

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

-      útil para secciones de un programa donde la eficiencia es crítica y no
+      útil para secciones de un programa donde el rendimiento es crítico y no

       se pueden tolerar grandes pausas como las que puede provocar el
       recolector.
 
       se pueden tolerar grandes pausas como las que puede provocar el
       recolector.
 

-**Optimizaciones**
-
-   *p_cache*, *size_cache*:
+Optimizaciones
+   *p_cache*, *size_cache*

       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é*.
 
       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*:
+   *minAddr*, *maxAddr*

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


@@ -1048,29 +1058,29 @@ 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`):
 

-*baseAddr* y *topAddr*:
+*baseAddr* y *topAddr*

    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).
 
    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*:
+*mark*, *scan*, *freebits*, *finals*, *noscan*

    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.
 
    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*:
+*npages*

    cantidad de páginas que contiene este *pool* (fue nombrado
    *number_of_pages* en las secciones anteriores para mayor claridad).
 
    cantidad de páginas que contiene este *pool* (fue nombrado
    *number_of_pages* en las secciones anteriores para mayor claridad).
 

-*ncommitted*:
+*ncommitted*

    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).
 
    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*:
+*pagetable*

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


@@ -1083,8 +1093,7 @@ La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura
    Vista gráfica de la estructura de un *pool* de memoria.
 
    .. aafig::
    Vista gráfica de la estructura de un *pool* de memoria.
 
    .. aafig::

-      :scale: 1.4
-      :aspect: 0.45
+      :scale: 120

 
                 /---  "baseAddr"    "ncommitted = i"          "topAddr" ---\
                 |                       V                                  |
 
                 /---  "baseAddr"    "ncommitted = i"          "topAddr" ---\
                 |                       V                                  |


@@ -1104,7 +1113,7 @@ La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura
 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

-una gran porción contínua de memoria sin estar intercalada con
+una gran porción continua de memoria sin estar intercalada con

 meta-información del recolector.
 
 Para poder acceder a los bits de un bloque en particular, se utiliza la
 meta-información del recolector.
 
 Para poder acceder a los bits de un bloque en particular, se utiliza la


@@ -1130,71 +1139,69 @@ un puntero al primer elemento de la lista en particular.
 
 La implementación utiliza a los bloques de memoria como nodos directamente.
 Como los bloques siempre pueden almacenar una palabra (el bloque de menor
 
 La implementación utiliza a los bloques de memoria como nodos directamente.
 Como los bloques siempre pueden almacenar una palabra (el bloque de menor

-tamaño es de 16 bytes y una palabra ocupa comunmente entre 4 y 8 bytes según
+tamaño es de 16 bytes y una palabra ocupa comúnmente entre 4 y 8 bytes según

 se trabaje sobre arquitecturas de 32 o 64 bits respectivamente), se almacena
 el puntero al siguiente en la primera palabra del bloque.
 
 
 Algoritmos
 ^^^^^^^^^^
 se trabaje sobre arquitecturas de 32 o 64 bits respectivamente), se almacena
 el puntero al siguiente en la primera palabra del bloque.
 
 
 Algoritmos
 ^^^^^^^^^^

-Los algoritmos en la implementación real están considerablemente menos
-modularizados que los presentados en la sección :ref:`dgc_algo`. Por ejemplo,
-la función ``collect()`` es una gran función de 300 líneas de código.
+Los algoritmos en la implementación real son considerablemente menos modulares
+que los presentados en la sección :ref:`dgc_algo`. Por ejemplo, la función
+``collect()`` es una gran función de 300 líneas de código.

 
 A continuación se resumen las funciones principales, separadas en categorías
 para facilitar la comprensión. Los siguientes son métodos de la estructura
 ``Gcx``:
 
 
 A continuación se resumen las funciones principales, separadas en categorías
 para facilitar la comprensión. Los siguientes son métodos de la estructura
 ``Gcx``:
 

-**Inicialización y terminación**
-
-   *initialize()*:
+Inicialización y terminación
+   *initialize()*

       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.
 
       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()*:
+   *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
       usuario.
 
       agrega, remueve e itera sobre las raíces simples definidas por el
       usuario.
 

-   *addRange(pbot, ptop)*, *remove range(pbot)*, *rangeIter(dg)*:
+   *addRange(pbot, ptop)*, *remove range(pbot)*, *rangeIter(dg)*

       agrega, remueve e itera sobre los rangos de raíces definidas por el
       usuario.
 
       agrega, remueve e itera sobre los rangos de raíces definidas por el
       usuario.
 

-**Manipulación de indicadores**
-
-   Cada bloque (*bin* en la terminología de la implementación del recolector)
-   tiene ciertos indicadores asociados. Algunos de ellos pueden ser
-   manipulados (indirectamente) por el usuario utilizando estas funciones:
-
-   *getBits(pool, biti)*:
+Manipulación de indicadores
+   *getBits(pool, biti)*

       obtiene los indicadores especificados para el bloque de índice ``biti``
       en el *pool* ``pool``.
 
       obtiene los indicadores especificados para el bloque de índice ``biti``
       en el *pool* ``pool``.
 

-   *setBits(pool, biti, mask)*:
+   *setBits(pool, biti, mask)*

       establece los indicadores especificados en ``mask`` para el bloque de
       índice ``biti`` en el *pool* ``pool``.
 
       establece los indicadores especificados en ``mask`` para el bloque de
       índice ``biti`` en el *pool* ``pool``.
 

-   *clrBits(pool, biti, mask)*:
+   *clrBits(pool, biti, mask)*

       limpia los indicadores especificados en ``mask`` para el bloque de
       índice ``biti`` en el *pool* ``pool``.
 
       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)
+   tiene ciertos indicadores asociados. Algunos de ellos pueden ser
+   manipulados (indirectamente) por el usuario utilizando las funciones
+   mencionadas arriba.
+

    El parámetro ``mask`` debe ser una máscara de bits que puede estar
    compuesta por la conjunción de los siguientes valores:
 
    El parámetro ``mask`` debe ser una máscara de bits que puede estar
    compuesta por la conjunción de los siguientes valores:
 

-   *FINALIZE*:
+   *FINALIZE*

       el objeto almacenado en el bloque tiene un destructor (indicador
       *finals*).
 
       el objeto almacenado en el bloque tiene un destructor (indicador
       *finals*).
 

-   *NO_SCAN*:
+   *NO_SCAN*

       el objeto almacenado en el bloque no contiene punteros (indicador
       *noscan*).
 
       el objeto almacenado en el bloque no contiene punteros (indicador
       *noscan*).
 

-   *NO_MOVE*:
+   *NO_MOVE*

       el objeto almacenado en el bloque no debe ser movido [#dgcmove]_.
 
 .. [#dgcmove] Si bien el recolector actual no tiene la capacidad de mover
       el objeto almacenado en el bloque no debe ser movido [#dgcmove]_.
 
 .. [#dgcmove] Si bien el recolector actual no tiene la capacidad de mover


@@ -1203,44 +1210,39 @@ para facilitar la comprensión. Los siguientes son métodos de la estructura
    fijar objetos apuntados desde algún segmento no conservativo (objeto
    *pinned*).
 
    fijar objetos apuntados desde algún segmento no conservativo (objeto
    *pinned*).
 

-**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``
       (``find_block()`` según la sección :ref:`dgc_algo_mark`).
 
       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)*:
+   *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
       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()``).
 
       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)*:
+   *findBin(size)*

       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`).
 
       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**
-
-   Recordar que la ``pooltable`` siempre se mantiene ordenada según la
-   dirección de la primera página.
-
-   *reserve(size)*:
+Asignación de memoria
+   *reserve(size)*

       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).
 
       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()*:
+   *minimize()*

       minimiza el uso de la memoria retornando *pools* sin páginas usadas al
       sistema operativo.
 
       minimiza el uso de la memoria retornando *pools* sin páginas usadas al
       sistema operativo.
 

-   *newPool(n)*:
+   *newPool(n)*

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


@@ -1252,7 +1254,7 @@ para facilitar la comprensión. Los siguientes son métodos de la estructura
       3 MiB y así sucesivamente hasta 8 MiB. A partir de ahí siempre crea
       *pools* de 8 MiB o la cantidad pedida, si ésta es mayor.
 
       3 MiB y así sucesivamente hasta 8 MiB. A partir de ahí siempre crea
       *pools* de 8 MiB o la cantidad pedida, si ésta es mayor.
 

-   *Pool.initialize(n_pages)*:
+   *Pool.initialize(n_pages)*

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


@@ -1262,23 +1264,23 @@ para facilitar la comprensión. Los siguientes son métodos de la estructura
       atributo ``FINALIZE`` a un bloque, se inicializa el conjunto de bits
       ``finals`` de todo el *pool*.
 
       atributo ``FINALIZE`` a un bloque, se inicializa el conjunto de bits
       ``finals`` de todo el *pool*.
 

-   *allocPage(bin)*:
+   *allocPage(bin)*

       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()``).
 
       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()``).
 

-   *allocPages(n)*:
+   *allocPages(n)*

       Busca ``n`` cantidad de páginas consecutivas libres (análoga
       a ``find_pages(n)``).
 
       Busca ``n`` cantidad de páginas consecutivas libres (análoga
       a ``find_pages(n)``).
 

-   *malloc(size, bits)*:
+   *malloc(size, bits)*

       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.
 
       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)*:
+   *bigAlloc(size)*

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


@@ -1287,33 +1289,33 @@ para facilitar la comprensión. Los siguientes son métodos de la estructura
       el caso en que no se liberaron suficientes páginas para asignar el
       objeto grande y pasar directamente a crear un nuevo *pool*.
 
       el caso en que no se liberaron suficientes páginas para asignar el
       objeto grande y pasar directamente a crear un nuevo *pool*.
 

-   *free(p)*:
+   *free(p)*

       libera la memoria apuntada por ``p`` (análoga a ``delete()`` de la
       sección anterior).
 
       libera la memoria apuntada por ``p`` (análoga a ``delete()`` de la
       sección anterior).
 

-**Recolección**
+   Recordar que la ``pooltable`` siempre se mantiene ordenada según la
+   dirección de la primera página.

 
 

-   *mark(pbot, ptop)*:
-      marca un rango de memoria. Este método es análogo al ``mark()``
-      presentado en la sección :ref:`dgc_algo_mark` pero marca un rango
-      completo de memoria, lo que permite que sea considerablemente más
-      eficiente.
+Recolección
+   *mark(pbot, ptop)*
+      marca un rango de memoria. Este método es análogo al ``mark_range()``
+      presentado en la sección :ref:`dgc_algo_mark`.

 
 

-   *fullcollectshell()*:
+   *fullcollectshell()*

       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
       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 desapilar, por lo tanto debe ser hecho en la misma
+      esta se volverían a des-apilar, por lo tanto debe ser hecho en la misma

       función ``collect()`` o en una función que luego la llame (como en este
       caso).
 
       función ``collect()`` o en una función que luego la llame (como en este
       caso).
 

-   *fullcollect(stackTop)*:
-      realiza la recolección de basura. Es análoga a ``collect()`` pero
-      considerablemente menos modularizada, 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 cantidad de páginas que se liberaron en la recolección, lo
-      que permite optimizar levemente la función ``bigAlloc()``.
+   *fullcollect(stackTop)*
+      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
+      cantidad de páginas que se liberaron en la recolección, lo que permite
+      optimizar levemente la función ``bigAlloc()``.

 
 
 Finalización
 
 
 Finalización


@@ -1329,10 +1331,12 @@ a ningún destructor), para el usuario puede ser una garantía muy débil
 y proveer finalización asegurada puede ser muy deseable.
 
 
 y proveer finalización asegurada puede ser muy deseable.
 
 

+.. _dgc_committed:
+

 Memoria *encomendada*
 ^^^^^^^^^^^^^^^^^^^^^
 El algoritmo actual divide un *pool* en dos áreas: memoria *encomendada*
 Memoria *encomendada*
 ^^^^^^^^^^^^^^^^^^^^^
 El algoritmo actual divide un *pool* en dos áreas: memoria *encomendada*

-(*committed* en inglés) y *no-encomentada*. Esto se debe a que originalmente
+(*committed* en inglés) y *no-encomendada*. Esto se debe a que originalmente

 el compilador de D_ DMD_ solo funcionaba en Microsoft Windows y este sistema
 operativo puede asignar memoria en dos niveles. Por un lado puede asignar al
 proceso un espacio de memoria (*address space*) pero sin asignarle la memoria
 el compilador de D_ DMD_ solo funcionaba en Microsoft Windows y este sistema
 operativo puede asignar memoria en dos niveles. Por un lado puede asignar al
 proceso un espacio de memoria (*address space*) pero sin asignarle la memoria


@@ -1385,7 +1389,7 @@ modernas que pueden observarse en el estado del arte (como :ref:`regiones
 <gc_free_list>`), es relativamente sofisticada. El esquema de *pools*
 y bloques permite disminuir considerablemente los problemas de *fragmentación*
 de memoria y evita búsquedas de *huecos* que pueden ser costosas (como
 <gc_free_list>`), es relativamente sofisticada. El esquema de *pools*
 y bloques permite disminuir considerablemente los problemas de *fragmentación*
 de memoria y evita búsquedas de *huecos* que pueden ser costosas (como

-*best-fit* [#dgcbestfit]_) o desperdiciar mucho especio (como *first-fit*
+*best-fit* [#dgcbestfit]_) o desperdiciar mucho espacio (como *first-fit*

 [#dgcfirstfit]_), logrando un buen equilibrio entre velocidad y espacio
 desperdiciado.
 
 [#dgcfirstfit]_), logrando un buen equilibrio entre velocidad y espacio
 desperdiciado.
 


@@ -1419,7 +1423,7 @@ cada pasada se realiza por sobre todo el *heap*).
 
 Conjuntos de bits para indicadores
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Conjuntos de bits para indicadores
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

-El algoritmo cláscio propone almacenar en la propia celda la marca (para la
+El algoritmo clásico propone almacenar en la propia celda la marca (para la

 fase de marcado) y otros indicadores. El algoritmo del recolector actual
 utiliza conjuntos de bits. Esto trae dos ventajas principales:
 
 fase de marcado) y otros indicadores. El algoritmo del recolector actual
 utiliza conjuntos de bits. Esto trae dos ventajas principales:
 


@@ -1428,11 +1432,78 @@ utiliza conjuntos de bits. Esto trae dos ventajas principales:
   de información.
 
 * Mejora la localidad de referencia, ya que los indicadores se escriben de
   de información.
 
 * Mejora la localidad de referencia, ya que los indicadores se escriben de

-  forma muy compacta y en una región de memoria contígua que generalmente
+  forma muy compacta y en una región de memoria contigua que generalmente

   puede entrar en el cache o en pocas páginas de memoria acelerando
   considerablemente la fase de marcado.
 
 
   puede entrar en el cache o en pocas páginas de memoria acelerando
   considerablemente la fase de marcado.
 
 

+.. _dgc_debug:
+
+Herramientas para depuración
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+El recolector provee algunas opciones para simplificar el diagnóstico
+y depuración de problemas, tanto del mismo recolector como del programa del
+usuario.
+
+Las opciones más importantes son:
+
+
+``MEMSTOMP``
+   Su función es escribir un patrón determinado de bits en todos los bytes de
+   un bloque de memoria según se haya:
+
+   * Pedido un bloque menor a una página (``0xF0``).
+   * Pedido un bloque mayor a una página (``0xF1``).
+   * Dejado de usar debido a un pedido de achicamiento de un bloque
+     (``0xF2``).
+   * Pedido más páginas debido a un pedido de agrandamiento de un bloque
+     (``0xF0``).
+   * Liberado intencionalmente por el usuario (``0xF2``).
+   * Barrido (``0xF3``).
+
+   Esto permite al diagnosticar un problema saber, por ejemplo, si un
+   determinado área de memoria fue recolectada recientemente, o liberada por
+   el usuario, o recién adquirida, etc. con tan solo ver si un patrón de bits
+   determinado está presente. Por supuesto puede existir *falsos positivos*
+   pero su probabilidad es lo suficientemente baja como para que sea útil en
+   la práctica.
+
+``SENTINEL``
+   Su función detectar errores producidos por escribir más allá (o antes) del
+   área de memoria solicitada y está implementado reservando un poco más de
+   memoria de la que pide el usuario, devolviendo un puntero a un bloque
+   ubicado dentro del bloque real reservado (en vez de al inicio) y finalmente
+   escribiendo un patrón de bits en los extremos del borde real (ver figura
+   :vref:`fig:sentinel`), de forma de poder verificar en distintas situación
+   (por ejemplo al barrer el bloque) que esas áreas de más con los patrones de
+   bits estén intactas. Esto permite detectar de forma temprana errores tanto
+   en el recolector como en el programa del usuario.
+
+   .. fig:: fig:sentinel
+
+      Esquema de un bloque cuando está activada la opción ``SENTINEL``.
+
+      .. aafig::
+         :textual:
+
+         |              |              |                              |        |
+         +-- Palabra ---+-- Palabra ---+-- Tamaño bloque de usuario --+- Byte -+
+         |              |              |                              |        |
+
+         +--------------+--------------+------------------------------+--------+
+         | "Tamaño del" |     Pre      |                              |  Post  |
+         |  "bloque de" |              |      Bloque de usuario       |        |
+         |   "usuario"  |  0xF4F4F4F4  |                              |  0xF5  |
+         +--------------+--------------+------------------------------+--------+
+                                       A
+                                       |
+                   Puntero devuleto ---/
+
+Ambas opciones son seleccionables sólo en tiempo de compilación del
+recolector, por lo que su utilidad real, al menos para el usuario, se ve
+severamente reducida.
+

 
 .. _dgc_bad:
 
 
 .. _dgc_bad:
 


@@ -1441,17 +1512,19 @@ Problemas y limitaciones
 
 A continuación se presentan los principales problemas encontrados en la
 implementación actual del recolector de basura de D_. Estos problemas surgen
 
 A continuación se presentan los principales problemas encontrados en la
 implementación actual del recolector de basura de D_. Estos problemas surgen

-principalmente de la observación del código y de aproximadamente 3 años de
+principalmente de la observación del código y de aproximadamente tres años de

 participación y observación del grupo de noticias, de donde se obtuvieron los
 principales problemas percibidos por la comunidad que utiliza el lenguaje.
 
 
 participación y observación del grupo de noticias, de donde se obtuvieron los
 principales problemas percibidos por la comunidad que utiliza el lenguaje.
 
 

+.. _dgc_bad_code:
+

 Complejidad del código y documentación
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 El análisis del código fue muy complicado debido a la falta de documentación
 y desorganización del código. Además se nota que el recolector ha sido escrito
 en una fase muy temprana y que a ido evolucionando a partir de ello de forma
 Complejidad del código y documentación
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 El análisis del código fue muy complicado debido a la falta de documentación
 y desorganización del código. Además se nota que el recolector ha sido escrito
 en una fase muy temprana y que a ido evolucionando a partir de ello de forma

-desprolija y sin ser rescrito nunca para aprovechar las nuevas características
+descuidada y sin ser rescrito nunca para aprovechar las nuevas características

 que el lenguaje fue incorporando (por ejemplo *templates*).
 
 Estos dos problemas (código complicado y falta de documentación) producen un
 que el lenguaje fue incorporando (por ejemplo *templates*).
 
 Estos dos problemas (código complicado y falta de documentación) producen un


@@ -1553,9 +1626,9 @@ Se recuerda que la semántica de dicha función es la misma que la de la funció
 ``new_big()`` presentada en :ref:`dgc_algo_alloc`.
 
 Además, como se comentó en la sección anterior, los algoritmos en la
 ``new_big()`` presentada en :ref:`dgc_algo_alloc`.
 
 Además, como se comentó en la sección anterior, los algoritmos en la

-implementación real están considerablemente menos modularizados que los
-presentados en la sección :ref:`dgc_algo`. Por ejemplo, la función
-``fullcollect()`` son 300 líneas de código.
+implementación real son considerablemente menos modulares que los presentados
+en la sección :ref:`dgc_algo`. Por ejemplo, la función ``fullcollect()`` son
+300 líneas de código.

 
 
 Memoria *encomendada*
 
 
 Memoria *encomendada*


@@ -1571,16 +1644,16 @@ discutible.
 
 Precisión
 ^^^^^^^^^
 
 Precisión
 ^^^^^^^^^

-Este fue historicamente uno de los problemas principales del recolector de D_
+Este fue históricamente uno de los problemas principales del recolector de D_

 [NGD46407]_ [NGD35364]_. Sin embargo, desde que, en la versión 1.001, se ha
 incorporado la capacidad de marcar un bloque como de datos puros (no contiene
 punteros, el atributo ``NO_SCAN``) [NGA6842]_, la gravedad de esos problemas ha
 [NGD46407]_ [NGD35364]_. Sin embargo, desde que, en la versión 1.001, se ha
 incorporado la capacidad de marcar un bloque como de datos puros (no contiene
 punteros, el atributo ``NO_SCAN``) [NGA6842]_, la gravedad de esos problemas ha

-disminuído considerablemente, aunque siguieron reportándose problemas más
+disminuido considerablemente, aunque siguieron reportándose problemas más

 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
 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 mostro un interés
+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
 avances al respecto.
 
 general por tener un recolector más preciso [NGDN87831]_, pero no han habido
 avances al respecto.
 


@@ -1594,8 +1667,8 @@ y en particular para mejorar la implementación de de arreglos asociativos.
 Referencias débiles
 ^^^^^^^^^^^^^^^^^^^
 El recolector actual no dispone de soporte de *referencias débiles*
 Referencias débiles
 ^^^^^^^^^^^^^^^^^^^
 El recolector actual no dispone de soporte de *referencias débiles*

-[#dgcweakref]_, sin embargo hay una demanda [NGD86840]_ [NGD13301]_ [NGL8264]_
-[NGD69761]_ [NGD74624]_ [NGD88065]_
+[#dgcweakref]_, sin embargo hay una demanda apreciable [NGD86840]_ [NGD13301]_
+[NGL8264]_ [NGD69761]_ [NGD74624]_ [NGD88065]_.

 
 .. [#dgcweakref] Una referencia débil (o *weak reference* en inglés) es
    aquella que que no protege al objeto referenciado de ser reciclado por el
 
 .. [#dgcweakref] Una referencia débil (o *weak reference* en inglés) es
    aquella que que no protege al objeto referenciado de ser reciclado por el


@@ -1604,7 +1677,7 @@ El recolector actual no dispone de soporte de *referencias débiles*
 Para cubrir esta demanda, se han implementado soluciones como biblioteca para
 suplir la inexistencia de una implementación oficial [NGA9103]_.
 
 Para cubrir esta demanda, se han implementado soluciones como biblioteca para
 suplir la inexistencia de una implementación oficial [NGA9103]_.
 

-Sin embargo éstas son en general poco robustas y extremadamente dependientes
+Sin embargo éstas son en general poco robustas, extremadamente dependientes

 de la implementación del recolector y, en general, presentan problemas muy
 sutiles [NGD88065]_. Por esta razón se ha discutido la posibilidad de incluir
 la implementación de *referencias débiles* como parte del lenguaje
 de la implementación del recolector y, en general, presentan problemas muy
 sutiles [NGD88065]_. Por esta razón se ha discutido la posibilidad de incluir
 la implementación de *referencias débiles* como parte del lenguaje


@@ -1624,7 +1697,7 @@ memoria [NGD75952]_ [NGDN87831]_.
 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
 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, historicamente una de las principales críticas
+requerimientos de tiempo real, históricamente una de las principales críticas

 al lenguaje [NGDN87831]_ [NGL3937]_ [NGD22968]_ [NGA15246]_ [NGD5622]_
 [NGD2547]_ [NGD18354]_.
 
 al lenguaje [NGDN87831]_ [NGL3937]_ [NGD22968]_ [NGA15246]_ [NGD5622]_
 [NGD2547]_ [NGD18354]_.
 


@@ -1648,71 +1721,102 @@ un recolector que de este tipo de garantías [NGD88298]_.
 
 Además los objetos pueden ser finalizados tanto determinísticamente
 (utilizando ``delete`` o ``scope``; ver secciones :ref:`d_low_level`
 
 Además los objetos pueden ser finalizados tanto determinísticamente
 (utilizando ``delete`` o ``scope``; ver secciones :ref:`d_low_level`

-y :ref:`d_dbc`) como no deterministicamente (cuando son finalizados por el
+y :ref:`d_dbc`) como no determinísticamente (cuando son finalizados por el

 recolector). En el primer caso se puede, por ejemplo, acceder sus atributos
 u otra memoria que se conozca *viva*, mientras que en el segundo no. Sin
 embargo un destructor no puede hacer uso de esta distinción, haciendo que la
 finalización determinística tenga a fines prácticos las mismas restricciones
 recolector). En el primer caso se puede, por ejemplo, acceder sus atributos
 u otra memoria que se conozca *viva*, mientras que en el segundo no. Sin
 embargo un destructor no puede hacer uso de esta distinción, haciendo que la
 finalización determinística tenga a fines prácticos las mismas restricciones

-que la finalización no deterministica. Es por esto que se ha sugerido permitir
+que la finalización no determinística. Es por esto que se ha sugerido permitir

 al destructor distinguir estos dos tipos de finalización [NGD89302]_.
 
 
 Eficiencia
 ^^^^^^^^^^
 al destructor distinguir estos dos tipos de finalización [NGD89302]_.
 
 
 Eficiencia
 ^^^^^^^^^^

-La eficiencia en general del recolector es una de las críticas frecuentes. Si
+El rendimiento en general del recolector es una de las críticas frecuentes. Si

 bien hay muchos problemas que han sido resueltos, en especial por la inclusión
 de un mínimo grado de precisión en la versión 1.001, en la actualidad se
 siguen encontrando en el grupo de noticias críticas respecto a esto
 [NGD43991]_ [NGD67673]_ [NGD63541]_ [NGD90977]_.
 
 bien hay muchos problemas que han sido resueltos, en especial por la inclusión
 de un mínimo grado de precisión en la versión 1.001, en la actualidad se
 siguen encontrando en el grupo de noticias críticas respecto a esto
 [NGD43991]_ [NGD67673]_ [NGD63541]_ [NGD90977]_.
 

-La principal causa de la ineficiencia del recolector actual es, probablemente,
-lo simple de su algoritmo principal de recolección. Más allá de una
-organización del *heap* moderadamente apropiada y de utilizar conjuntos de
+La principal causa del bajo rendimiento del recolector actual es,
+probablemente, lo simple de su algoritmo principal de recolección. Más allá de
+una organización del *heap* moderadamente apropiada y de utilizar conjuntos de

 bits para la fase de marcado, el resto del algoritmo es casi la versión más
 básica de marcado y barrido. Hay mucho lugar para mejoras en este sentido.
 
 
 bits para la fase de marcado, el resto del algoritmo es casi la versión más
 básica de marcado y barrido. Hay mucho lugar para mejoras en este sentido.
 
 

+Configurabilidad
+^^^^^^^^^^^^^^^^
+Si bien el recolector actual tiene algunas características configurables,
+todas son seleccionables sólo en tiempo de compilación del recolector (no del
+programa del usuario), como por ejemplo las opciones descriptas en
+:ref:`dgc_debug`. Por lo tanto, a nivel práctico, es como si no tuviera
+posibilidad alguna de ser configurado por el usuario, ya que no es parte del
+ciclo de desarrollo normal el recompilar el recolector o *runtime* de un
+lenguaje.
+
+Dado que es imposible que un recolector sea óptimo para todo tipo de
+programas, es muy deseable permitir una configuración de parámetros del
+recolector que permitan al usuario ajustarlo a las necesidades particulares de
+sus programas.
+
+
+.. _dgc_bad_ocup:
+
+Factor de ocupación del *heap*
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Otro problema potencialmente importante del recolector actual es que no se
+tiene ningún cuidado con respecto a que, luego de una recolección, se haya
+recuperado una buena parte del *heap*. Por lo tanto, en casos extremos, el
+recolector tiene que hacer una recolección por cada petición de memoria, lo
+que es extremadamente ineficiente.
+
+Para evitar esto, habría que usar algún esquema para evaluar cuando una
+recolección no fue lo suficientemente *exitosa* y en ese caso pedir más
+memoria al sistema operativo.
+
+

 Detalles
 ^^^^^^^^
 Finalmente hay varios detalles en la implementación actual que podrían
 mejorarse:
 
 Detalles
 ^^^^^^^^
 Finalmente hay varios detalles en la implementación actual que podrían
 mejorarse:
 

-Listas de libres:
-  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:
-  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 con
-  distintos tamaños de bloque, se reserva una cantidad de bits igual a la
-  mayor cantidad posible de bloques que puede haber en el *pool*; es decir, se
-  reserva 1 bit por cada 16 bytes del *pool*. Para un *pool* de 1 MiB (tamaño
-  mínimo), teniendo en cuenta que se utilizan 5 conjuntos de bits (``mark``,
-  ``scan``, ``finals``, ``freebits`` y ``noscan``), se utilizan 40 KiB de
-  memoria para conjuntos de bits (un 4% de *desperdicio* si, por ejemplo, ese
-  *pool* estuviera destinado por completo a albergar un solo objeto grande; lo
-  que equivaldría al 2560 objetos de 16 bytes desperdiciados en bits
-  inutilizados).
-
-Repetición de código:
-   Hay algunos fragmentos de código repetidos inecesariamente. Por ejemplo en
+Listas de libres
+   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
+   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
+   con distintos tamaños de bloque, se reserva una cantidad de bits igual a la
+   mayor cantidad posible de bloques que puede haber en el *pool*; es decir,
+   se reserva 1 bit por cada 16 bytes del *pool*. Para un *pool* de 1 MiB
+   (tamaño mínimo), teniendo en cuenta que se utilizan 5 conjuntos de bits
+   (``mark``, ``scan``, ``finals``, ``freebits`` y ``noscan``), se utilizan 40
+   KiB de memoria para conjuntos de bits (un 4% de *desperdicio* si, por
+   ejemplo, ese *pool* estuviera destinado por completo a albergar un solo
+   objeto grande; lo que equivaldría al 2560 objetos de 16 bytes
+   desperdiciados en bits inutilizados).
+
+Repetición de código
+   Hay algunos fragmentos de código repetidos innecesariamente. Por ejemplo en

    varios lugares se utilizan arreglos de tamaño variable que se implementan
    repetidas veces (en general como un puntero al inicio del arreglo más el
    tamaño actual del arreglo más el tamaño de la memoria total asignada
    actualmente). Esto es propenso a errores y difícil de mantener.
 
    varios lugares se utilizan arreglos de tamaño variable que se implementan
    repetidas veces (en general como un puntero al inicio del arreglo más el
    tamaño actual del arreglo más el tamaño de la memoria total asignada
    actualmente). Esto es propenso a errores y difícil de mantener.
 

-Uso de señales:
+Uso de señales

    el recolector actual utiliza las señales del sistema operativo ``SIGUSR1``
    y ``SIGUSR2`` para pausar y reanudar los hilos respectivamente. Esto
    el recolector actual utiliza las señales del sistema operativo ``SIGUSR1``
    y ``SIGUSR2`` para pausar y reanudar los hilos respectivamente. Esto

-   puede traer incovenientes a usuarios que desean utilizar estas
+   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]_.
 
    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:
+Marcado iterativo

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


@@ -1721,4 +1825,4 @@ Marcado iterativo:
 
 .. include:: links.rst
 
 
 .. include:: links.rst
 

-.. vim: set ts=3 sts=3 sw=3 et tw=78 :
+.. vim: set ts=3 sts=3 sw=3 et tw=78 spelllang=es :