]> git.llucax.com Git - z.facultad/75.00/informe.git/blobdiff - source/dgc.rst
Mencionar ionice(1) en la metodología de pruebas
[z.facultad/75.00/informe.git] / source / dgc.rst
index 85ff7b4988368c572a3ea7d9c8e630f7070723f9..497e20eef6fac2fe0f3193cd5dd8c9f5e6063cbc 100644 (file)
@@ -1,31 +1,24 @@
 
 
-.. 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, CORREGIDO
-
-
 .. _dgc:
 
 Recolección de basura en D
 ============================================================================
 
 D_ propone un nuevo desafío en cuanto al diseño de un recolector de basura,
 .. _dgc:
 
 Recolección de basura en D
 ============================================================================
 
 D_ propone un nuevo desafío en cuanto al diseño de un recolector de basura,
-debido a la gran cantidad características que tiene y paradigmas que soporta.
+debido a la gran cantidad de características que tiene y paradigmas que
+soporta.
 
 D_ ya cuenta con un recolector que hace lo necesario para funcionar de forma
 
 D_ ya cuenta con un recolector que hace lo necesario para funcionar de forma
-aceptable, pero su diseño e implementación son relativamente sencillas
-comparadas con el :ref:`estado del arte <gc_art>` de la recolección de basura
+aceptable, pero su diseño e implementación son relativamente sencillos
+comparados con el :ref:`estado del arte <gc_art>` de la recolección de basura
 en general. Además la implementación actual presenta una serie de problemas
 que se evidencia en las quejas que regularmente la comunidad de usuarios de D_
 menciona en el grupo de noticias.
 
 En esta sección se analizarán las necesidades particulares de D_ con respecto
 a la recolección de basura. También se analiza el diseño e implementación del
 en general. Además la implementación actual presenta una serie de problemas
 que se evidencia en las quejas que regularmente la comunidad de usuarios de D_
 menciona en el grupo de noticias.
 
 En esta sección se analizarán las necesidades particulares de D_ con respecto
 a la recolección de basura. También se analiza el diseño e implementación del
-recolector actual y finalmente se presenta una recompilación de los
-principales problemas que presenta.
+recolector actual, presentando sus fortalezas y debilidades. Finalmente se
+analiza la viabilidad de los diferentes algoritmos vistos en :ref:`gc_art`.
 
 
 
 
 
 
@@ -60,11 +53,11 @@ memoria de éste. Esta característica es muy inusual en un recolector,
 a excepción de recolectores conservativos diseñados para C/C++ que tienen las
 mismas (o más) limitaciones.
 
 a excepción de recolectores conservativos diseñados para C/C++ que tienen las
 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
-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
+La posibilidad de controlar 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 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.
@@ -130,7 +123,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
@@ -142,7 +135,7 @@ La especificación dice:
 
 Afortunadamente el orden de finalización no está definido, ya que esto sería
 extremadamente difícil de proveer por un recolector (si no imposible). Esto
 
 Afortunadamente el orden de finalización no está definido, ya que esto sería
 extremadamente difícil de proveer por un recolector (si no imposible). Esto
-significa que si bien se ejecutan el destructores de los objetos que dejan de
+significa que si bien se ejecutan los destructores de los objetos que dejan de
 ser alcanzables desde el *root set*, no se define en que orden se hace, y por
 lo tanto un objeto no puede acceder a sus atributos que sean referencias
 a otros objetos en un destructor.
 ser alcanzables desde el *root set*, no se define en que orden se hace, y por
 lo tanto un objeto no puede acceder a sus atributos que sean referencias
 a otros objetos en un destructor.
@@ -155,17 +148,17 @@ 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
 permite.
 
 orden en que fueron creados (y por lo tanto en que serán destruidos) se lo
 permite.
 
-Sin embargo no hay forma actualmente de saber dentro de un destructor si este
+Sin embargo no hay forma actualmente de saber dentro de un destructor si éste
 fue llamado determinísticamente o no, por lo tanto es virtualmente imposible
 hacer uso de esta distinción, a menos que una clase sea declarada para ser
 creada solamente utilizando la palabra reservada ``scope``.
 
 fue llamado determinísticamente o no, por lo tanto es virtualmente imposible
 hacer uso de esta distinción, a menos que una clase sea declarada para ser
 creada solamente utilizando la palabra reservada ``scope``.
 
-Cabe aclarar que estrictamente hablando, según la especificación de D_, el
+Cabe aclarar que, estrictamente hablando y según la especificación de D_, el
 recolector no debe garantizar la finalización de objetos bajo ninguna
 circunstancia, es decir, el recolector podría no llamar a ningún destructor.
 recolector no debe garantizar la finalización de objetos bajo ninguna
 circunstancia, es decir, el recolector podría no llamar a ningún destructor.
-Sin embargo esto es probablemente un problema de redacción vaga y dadas las
+Sin embargo esto es probablemente una vaguedad en la redacción y dadas las
 garantías que provee la implementación actual la comunidad de D_ cuenta con
 garantías que provee la implementación actual la comunidad de D_ cuenta con
-ellas porque además son deseables (y sencillas de implementar).
+ellas.
 
 
 
 
 
 
@@ -176,15 +169,14 @@ Recolector de basura actual de D
 
 Como paso básico fundamental para poder mejorar el recolector de basura de D_,
 primero hay que entender la implementación actual, de forma de conocer sus
 
 Como paso básico fundamental para poder mejorar el recolector de basura de D_,
 primero hay que entender la implementación actual, de forma de conocer sus
-puntos fuertes, problemas y limitaciones, de manera tal de poder analizar
-formas de mejorarlo.
+puntos fuertes, problemas y limitaciones.
 
 
-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
+Como se mencionó en la sección :ref:`d_lang`, 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
 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 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).
+surgió como alternativa a Phobos_ dado que estaba 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).
 
 Dado que Tango_ está mejor organizada, su desarrollo es más abierto (aceptan
 cambios y mejoras) y que hay una mayor disponibilidad de programas
 
 Dado que Tango_ está mejor organizada, su desarrollo es más abierto (aceptan
 cambios y mejoras) y que hay una mayor disponibilidad de programas
@@ -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
@@ -296,17 +288,17 @@ dicho objeto.
       | +----------+ +----------+              +----------+     +----------+ |
       +----------------------------------------------------------------------+
 
       | +----------+ +----------+              +----------+     +----------+ |
       +----------------------------------------------------------------------+
 
-Cada página de un *pool* puede estar asignada a contener bloques de un tamaño
-específico o puede estar libre. A su vez, cada bloque puede estar ocupado por
-una celda o estar libre. Los bloques libres de un tamaño específico (a
-excepción de aquellos bloques que ocupen una página entera) además forman
-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.
+Cada página de un *pool* puede tener asignado un tamaño de bloque específico
+o puede estar libre. A su vez, cada bloque puede estar ocupado por una celda
+o estar libre. Los bloques libres de un tamaño específico (a excepción de
+aquellos bloques que ocupen una página entera) además forman 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.
 
 
-.. 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
 
@@ -337,12 +329,12 @@ Atributos de *pool*
 ^^^^^^^^^^^^^^^^^^^
 Cada *pool* tiene la siguiente información asociada:
 
 ^^^^^^^^^^^^^^^^^^^
 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
+*number_of_pages*
+   Cantidad de páginas que tiene. Esta cantidad es fija en toda la vida de un
    *pool*.
 
    *pool*.
 
-*pages*:
-   bloque de memoria contiguo 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).
 
 
@@ -356,18 +348,18 @@ Una página siempre almacena bloques del mismo tamaño, que pueden ser 16, 32,
 ``PAGE``). Además hay dos tamaños de bloque simbólicos que tienen un
 significado especial:
 
 ``PAGE``). Además hay dos tamaños de bloque simbólicos que tienen un
 significado especial:
 
-``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).
+``FREE``
+   Indica que la página está completamente libre y 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,
-   que ocupa una o más páginas). Luego se presentan más detalles sobre objetos
+``CONTINUATION``
+   Indica que esta página es la continuación de un objeto grande (es decir,
+   que ocupa dos o más páginas). Luego se presentan más detalles sobre objetos
    grandes.
 
    grandes.
 
-Las páginas con esto tamaños de bloque especiales (conceptualmente) no
+Las páginas con estos tamaños de bloque especiales conceptualmente no
 contienen bloques.
 
 
 contienen bloques.
 
 
@@ -375,30 +367,30 @@ Atributos de bloque
 ^^^^^^^^^^^^^^^^^^^
 Cada bloque tiene asociados varios atributos:
 
 ^^^^^^^^^^^^^^^^^^^
 Cada bloque tiene asociados varios atributos:
 
-*mark*:
-   utilizado en la fase de :ref:`marcado <dgc_algo_mark>`, indica que un nodo
+*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>`).
 
    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
+*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>`).
 
    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
+*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
    *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*).
+   :ref:`algoritmo actual <dgc_algo>` (las celdas con 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
+*final*
+   Indica que el bloque contiene un objeto que tiene un destructor (que debe
    ser llamado cuando la celda pasa de *viva* a *basura*).
 
    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
-   tanto no debe ser marcado de forma conservativa (no tiene *hijas*).
+*noscan*
+   Indica que el bloque contiene un objeto que no tiene punteros y por lo
+   tanto no debe ser escaneado (no tiene *hijas*).
 
 
 Objetos grandes
 
 
 Objetos grandes
@@ -451,37 +443,54 @@ básicas de cualquier algoritmo de :ref:`marcado y barrido <gc_mark_sweep>`::
 
 Fase de marcado
 ^^^^^^^^^^^^^^^
 
 Fase de marcado
 ^^^^^^^^^^^^^^^
-Esta fase consiste de varios pasos, que pueden resumirse en el siguiente
+Esta fase consiste de varios pasos, que pueden describirse con 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()
       stop_the_world()
       clear_mark_scan_bits()
       mark_free_lists()
       mark_static_data()
-      push_registers_into_stack()
+      push_registers_into_stack(thread_self)
+      thread_self.stack.end = get_stack_top()
       mark_stacks()
       mark_stacks()
+      pop_registers_from_stack(thread_self)
       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 apilan los registros del procesador en el *stack* y se guarda la posición
+actual del *stack* para que la fase de marcado pueda recorrerlos [#dgcstw]_::
 
    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)
+         thread.stack.end = get_stack_top()
 
    function start_the_world() is
 
    function start_the_world() is
-      foreach thread in threads
+      foreach thread in reversed(threads)
+         if thread is thread_self
+            continue
+         pop_registers_from_stack(thread)
          thread.resume()
 
          thread.resume()
 
+.. [#dgcstw] El procedimiento para apilar y desapilar los registros en el
+   *stack* se realiza en realidad utilizando las señales ``SIGUSR1``
+   y ``SIGUSR2`` (respectivamente). Es el manejador de la señal el que en
+   realidad apila y desapila los registros y guarda el puntero al *stack*. Se
+   omiten los detalles para simplificar la explicación del algoritmo.
+
 La función ``clear_mark_scan_bits()`` se encarga de restablecer todos los
 atributos *mark* y *scan* de cada bloque del *heap*::
 
 La función ``clear_mark_scan_bits()`` se encarga de restablecer todos los
 atributos *mark* y *scan* de cada bloque del *heap*::
 
@@ -497,10 +506,10 @@ 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
 
    function mark_free_lists() is
-      foreach free_list in heap
+      foreach free_list in free_lists
          foreach block in free_list
             block.mark = true
             block.free = true
          foreach block in free_list
             block.mark = true
             block.free = true
@@ -517,25 +526,29 @@ 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::
 
-   function push_registers_into_stack() is
-      foreach register in registers
+   function push_registers_into_stack(thread) is
+      foreach register in thread.registers
          push(register)
 
          push(register)
 
+Y luego, al reiniciar los hilos cuando se termina de marcar, se descartan
+sacándolos de la pila (no es necesario ni correcto restablecer los valores ya
+que podrían tener nuevos valores)::
+
+   function pop_registers_from_stack(thread) is
+      foreach register in reverse(thread.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
 
 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
@@ -546,20 +559,23 @@ 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 +584,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,15 +593,11 @@ 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
 :ref:`abstracción tricolor <gc_intro_tricolor>`: todas las celdas alcanzables
 
 Aquí puede verse, con un poco de esfuerzo, la utilización de la
 :ref:`abstracción tricolor <gc_intro_tricolor>`: todas las celdas alcanzables
@@ -616,7 +628,7 @@ utilizadas en la fase de marcado::
                big_object_end = find_big_object_end(pool, page)
                if big_object_start <= pointer < big_object_end
                   return [pool, page, big_object_start]
                big_object_end = find_big_object_end(pool, page)
                if big_object_start <= pointer < big_object_end
                   return [pool, page, big_object_start]
-            else if page.bloc_size < PAGE
+            else if page.block_size < PAGE
                foreach block in page
                   block_start = cast(byte*) block
                   block_end = block_start + page.block_size
                foreach block in page
                   block_start = cast(byte*) block
                   block_end = block_start + page.block_size
@@ -665,23 +677,23 @@ 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
 biblioteca *runtime* y en última instancia llama al destructor del objeto
 almacenado en el bloque a liberar.
 
 
 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
 biblioteca *runtime* y en última instancia llama al destructor del objeto
 almacenado en el bloque a liberar.
 
-Una vez marcados todos los bloques y páginas como libre, se procede
-a reconstruir las listas de libres. En el proceso buscan las páginas que
-tengan todos los bloques libres para marcar la página completa como libre (de
-manera que pueda utilizarse para albergar otro tamaño de bloque u objetos
-grandes de ser necesario)::
+Una vez marcados todos los bloques y páginas con ``free``, se procede
+a reconstruir las listas de libres. Como parte de este proceso se buscan las
+páginas que tengan todos los bloques libres para marcar la página completa
+como libre (de manera que pueda utilizarse para albergar otro tamaño de bloque
+u objetos grandes de ser necesario)::
 
    function rebuild_free_lists() is
 
    function rebuild_free_lists() is
-      foreach free_list in heap
+      foreach free_list in free_lists
          free_list.clear()
       foreach pool in heap
          foreach page in pool
          free_list.clear()
       foreach pool in heap
          foreach page in pool
@@ -746,16 +758,15 @@ 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
 asignan de las siguiente manera::
 
 vez más el algoritmo distingue objetos grandes de pequeños. Los pequeños se
 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 +776,42 @@ 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::
+Donde ``pop_first()`` retorna ``null`` si la lista estaba vacía. 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
@@ -810,25 +824,25 @@ todo falla, la función ``new()`` termina lanzando una excepción indicando que
 se agotó la memoria.
 
 Si el tamaño de bloque necesario para cumplir con la asignación de memoria es
 se agotó la memoria.
 
 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
+de una o más páginas, entonces se utiliza otro algoritmo para alocar un objeto
 grande::
 
 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
 serie de páginas contiguas, dentro de un mismo *pool*, suficientes para
 
 De forma similar a la asignación de objetos pequeños, se intenta encontrar una
 serie de páginas contiguas, dentro de un mismo *pool*, suficientes para
@@ -840,9 +854,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
@@ -854,34 +868,34 @@ completamente libres::
 Volviendo a la función ``new_big()``, para hallar una serie de páginas
 contiguas se utiliza el siguiente algoritmo::
 
 Volviendo a la función ``new_big()``, para hallar una serie de páginas
 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
 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::
 
 
 Como se dijo, las páginas deben estar contenidas en un mismo *pool* (para
 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::
 
-      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
@@ -937,10 +951,10 @@ Detalles de implementación
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Hay varias diferencias a nivel de implementación entre lo que se presentó en
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 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á construido el recolector y algunas de
-sus optimizaciones principales.
+las secciones anteriores y como está escrito realmente el recolector actual.
+Con los conceptos e ideas principales ya explicadas, se procede 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_.
 
 
 Vale aclarar que el recolector de basura actual está implementado en D_.
 
@@ -951,60 +965,57 @@ 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*):
-      arreglo variable de punteros simples que son tomados como raíces
+Raíces definidas por el usuario
+   *roots* (*nroots*, *rootdim*)
+      Arreglo variable de punteros simples que son tomados como raíces
       provistas por el usuario.
 
       provistas por el usuario.
 
-   *ranges* (*nranges*, *rangedim*):
-      arreglo variable de rangos de memoria que deben ser revisados (de forma
+   *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.
 
       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*:
-      variable que indica si en la fase de marcado se encontraron nuevas
+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
       una iteración de marcado (utilizando la :ref:`abstracción tricolor
       <gc_intro_tricolor>`). Es análoga a la variable ``more_to_scan``
       presentada en :ref:`dgc_algo_mark`.
 
       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
       <gc_intro_tricolor>`). Es análoga a la variable ``more_to_scan``
       presentada en :ref:`dgc_algo_mark`.
 
-   *inited*:
-      indica si el recolector fue inicializado.
+   *inited* (sic)
+      Indica si el recolector fue inicializado.
 
 
-   *stackBottom*:
-      puntero a la base del *stack* (asumiendo que el stack crece hacia arriba).
+   *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.
 
       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).
+   *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.
 
       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
+   *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).
 
       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
+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.
 
       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
+   *log*
+      Indica si se debe guardar un registro de la actividad del recolector. Es
       utilizado principalmente para depuración.
 
       utilizado principalmente para depuración.
 
-   *disabled*:
-      indica que no se deben realizar recolecciones implícitamente. Si al
+   *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
       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
@@ -1012,17 +1023,16 @@ facilitar la comprensión):
       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*:
-      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é*.
+Optimizaciones
+   *p_cache*, *size_cache*
+      Caché del tamaño de bloque para un puntero dado. Obtener el tamaño de un
+      bloque 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 en un caché (de un solo
+      elemento) el último valor calculado.
 
 
-   *minAddr*, *maxAddr*:
-      punteros al principio y fin del *heap*. Pueden haber *huecos* entre
+   *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
       ú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
@@ -1042,45 +1052,16 @@ destacar que para implementar el recolector no se pueden utilizar los arreglos
 dinámicos de D_ (ver sección :ref:`d_high_level`) dado que éstos utilizan de
 forma implícita el recolector de basura, por lo tanto todos los arreglos
 variables del recolector se implementan utilizando las funciones de
 dinámicos de D_ (ver sección :ref:`d_high_level`) dado que éstos utilizan de
 forma implícita el recolector de basura, por lo tanto todos los arreglos
 variables del recolector se implementan utilizando las funciones de
-C ``malloc()``, ``realloc()`` y ``free()`` directamente.
+C :manpage:`malloc(3)`, :manpage:`realloc(3)` y :manpage:`free(3)`
+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*:
-   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*:
-   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*:
-   cantidad de páginas que contiene este *pool* (fue nombrado
-   *number_of_pages* en las secciones anteriores para mayor claridad).
-
-*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).
-
-*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
-   "``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
+.. flt:: fig:dgc-pool
 
 
-   Vista gráfica de la estructura de un *pool* de memoria.
+   Vista gráfica de la estructura de un *pool* de memoria
 
    .. aafig::
       :scale: 120
 
    .. aafig::
       :scale: 120
@@ -1100,9 +1081,39 @@ La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura
       pagetable | Bins 0 | Bins 1 | ... | Bins i | ... | "Bins (npages-1)" |
                 +--------+--------+-----+--------+-----+-------------------+
 
       pagetable | Bins 0 | Bins 1 | ... | Bins i | ... | "Bins (npages-1)" |
                 +--------+--------+-----+--------+-----+-------------------+
 
+*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).
+
+*mark*, *scan*, *freebits*, *finals*, *noscan*
+   Conjuntos 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*
+   Cantidad de páginas que contiene este *pool* (fue nombrado
+   *number_of_pages* en las secciones anteriores para mayor claridad).
+
+*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).
+
+*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
+   "``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``.
+
 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.
 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
+Esto simplifica el manejo de lo que es memoria *pura* del *heap*, ya que queda
 una gran porción continua de memoria sin estar intercalada con
 meta-información del recolector.
 
 una gran porción continua de memoria sin estar intercalada con
 meta-información del recolector.
 
@@ -1123,7 +1134,7 @@ no predomina un tamaño de bloque pequeño.
 Listas de libres
 ^^^^^^^^^^^^^^^^
 Las listas de libres se almacenan en el recolector como un arreglo de
 Listas de libres
 ^^^^^^^^^^^^^^^^
 Las listas de libres se almacenan en el recolector como un arreglo de
-estructuras ``Lista``, que se compone solamente de un atributo ``List* next``
+estructuras ``List``, que se compone solamente de un atributo ``List* next``
 (es decir, un puntero al siguiente). Entonces cada elemento de ese arreglo es
 un puntero al primer elemento de la lista en particular.
 
 (es decir, un puntero al siguiente). Entonces cada elemento de ese arreglo es
 un puntero al primer elemento de la lista en particular.
 
@@ -1138,63 +1149,61 @@ Algoritmos
 ^^^^^^^^^^
 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
 ^^^^^^^^^^
 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.
+``collect()`` es una gran función de 300 líneas de código fuente.
 
 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()*:
-      inicializa las estructuras internas del recolector para que pueda ser
+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.
 
       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.
+   *Dtor()*
+       Libera todas las estructuras que utiliza el recolector.
 
 
-**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
+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.
 
       usuario.
 
-   *addRange(pbot, ptop)*, *remove range(pbot)*, *rangeIter(dg)*:
-      agrega, remueve e itera sobre los rangos de raíces definidas por el
+   *addRange(pbot, ptop)*, *remove range(pbot)*, *rangeIter(dg)*
+      Agrega, remueve e itera sobre los rangos de raíces definidas por el
       usuario.
 
       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)*:
-      obtiene los indicadores especificados para el bloque de índice ``biti``
+Manipulación de bits indicadores
+   *getBits(pool, biti)*
+      Obtiene los indicadores especificados para el bloque de índice ``biti``
       en el *pool* ``pool``.
 
       en el *pool* ``pool``.
 
-   *setBits(pool, biti, mask)*:
-      establece los indicadores especificados en ``mask`` para el bloque de
+   *setBits(pool, biti, mask)*
+      Establece los indicadores especificados en ``mask`` para el bloque de
       índice ``biti`` en el *pool* ``pool``.
 
       índice ``biti`` en el *pool* ``pool``.
 
-   *clrBits(pool, biti, mask)*:
-      limpia los indicadores especificados en ``mask`` para el bloque de
+   *clrBits(pool, biti, mask)*
+      Limpia los indicadores especificados en ``mask`` para el bloque de
       índice ``biti`` en el *pool* ``pool``.
 
       í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*:
-      el objeto almacenado en el bloque tiene un destructor (indicador
+   *FINALIZE*
+      El objeto almacenado en el bloque tiene un destructor (indicador
       *finals*).
 
       *finals*).
 
-   *NO_SCAN*:
-      el objeto almacenado en el bloque no contiene punteros (indicador
+   *NO_SCAN*
+      El objeto almacenado en el bloque no contiene punteros (indicador
       *noscan*).
 
       *noscan*).
 
-   *NO_MOVE*:
-      el objeto almacenado en el bloque no debe ser movido [#dgcmove]_.
+   *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
    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
@@ -1202,45 +1211,40 @@ 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**
+Búsquedas
+   *findPool(p)*
+      Busca el *pool* al que pertenece el objeto apuntado por ``p``.
 
 
-   *findPool(p)*:
-      busca el *pool* al que pertenece el objeto apuntado por ``p``.
-
-   *findBase(p)*:
-      busca la dirección base (el inicio) del bloque apuntado por ``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`).
 
       (``find_block()`` según la sección :ref:`dgc_algo_mark`).
 
-   *findSize(p)*:
-      busca el tamaño del bloque apuntado por ``p``.
+   *findSize(p)*
+      Busca el tamaño del bloque apuntado por ``p``.
 
 
-   *getInfo(p)*:
-      obtiene información sobre el bloque apuntado por ``p``. Dicha
+   *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()``).
 
       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
+   *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`).
 
       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)*:
-      reserva un nuevo *pool* de al menos ``size`` bytes. El algoritmo nunca
+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).
 
       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
+   *minimize()*
+      Minimiza el uso de la memoria retornando *pools* sin páginas usadas al
       sistema operativo.
 
       sistema operativo.
 
-   *newPool(n)*:
-      reserva un nuevo *pool* con al menos ``n`` páginas. Junto con
+   *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
       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
@@ -1251,8 +1255,8 @@ 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)*:
-      inicializa un nuevo *pool* de memoria. Junto con ``newPool()`` es
+   *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
       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
@@ -1261,24 +1265,24 @@ 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)*:
-      asigna a una página libre el tamaño de bloque ``bin`` y enlaza los
+   *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()``).
 
       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)*:
-      asigna memoria para un objeto de tamaño ``size`` bytes. Análoga al
+   *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.
 
       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
+   *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
       ``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
@@ -1286,28 +1290,27 @@ 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)*:
-      libera la memoria apuntada por ``p`` (análoga a ``delete()`` de la
+   *free(p)*
+      Libera la memoria apuntada por ``p`` (análoga a ``delete()`` de la
       sección anterior).
 
       sección anterior).
 
-**Recolección**
-
-   *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.
-
-   *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
-      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).
+   Recordar que la ``pooltable`` siempre se mantiene ordenada según la
+   dirección de la primera página.
 
 
-   *fullcollect(stackTop)*:
-      realiza la recolección de basura. Es análoga a ``collect()`` pero es
+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()*
+      Guarda los registros del procesador asignado al hilo actual en su
+      *stack* y llama a ``fullcollect()``. El resto de los hilos son pausados
+      y sus registros apilados por la función del *runtime*
+      ``thread_suspendAll()`` (y restablecidos y reiniciados por
+      ``thread_resumeAll()``.
+
+   *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
       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
@@ -1328,15 +1331,17 @@ 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*
 (*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
 Memoria *encomendada*
 ^^^^^^^^^^^^^^^^^^^^^
 El algoritmo actual divide un *pool* en dos áreas: memoria *encomendada*
 (*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
-correspondiente. En un paso posterior se puede *encomendar* la memoria (es
-decir, asignar realmente la memoria).
+operativo puede asignar memoria en dos niveles. En principio se puede asignar
+al proceso un espacio de memoria (*address space*) pero sin asignarle la
+memoria virtual correspondiente. En un paso posterior se puede *encomendar* la
+memoria (es decir, asignar realmente la memoria virtual).
 
 Para aprovechar esta característica el recolector diferencia estos dos
 niveles. Sin embargo, esta diferenciación introduce una gran complejidad (que
 
 Para aprovechar esta característica el recolector diferencia estos dos
 niveles. Sin embargo, esta diferenciación introduce una gran complejidad (que
@@ -1345,9 +1350,10 @@ y convierte lo que es una ventaja en un sistema operativo en una desventaja
 para todos los demás (ya que los cálculos extra se realizan pero sin ningún
 sentido). De hecho hay sistemas operativos, como Linux_, que realizan este
 trabajo automáticamente (la memoria no es asignada realmente al programa hasta
 para todos los demás (ya que los cálculos extra se realizan pero sin ningún
 sentido). De hecho hay sistemas operativos, como Linux_, que realizan este
 trabajo automáticamente (la memoria no es asignada realmente al programa hasta
-que el programa no haga uso de ella; esta capacidad se denomina *overcommit*).
+que el programa no haga uso de ella; a esta capacidad se la denomina
+*overcommit*).
 
 
-Como se vio en la figura :vref:`fig:dgc-pool`, lás páginas de un *pool* se
+Como se vio en la figura :vref:`fig:dgc-pool`, las páginas de un *pool* se
 dividen en *committed* y *uncommitted*. Siempre que el recolector recorre un
 *pool* en busca de una página o bloque, lo hace hasta la memoria *committed*,
 porque la *uncommitted* es como si jamás se hubiera pedido al sistema
 dividen en *committed* y *uncommitted*. Siempre que el recolector recorre un
 *pool* en busca de una página o bloque, lo hace hasta la memoria *committed*,
 porque la *uncommitted* es como si jamás se hubiera pedido al sistema
@@ -1363,7 +1369,7 @@ soporta múltiples *mutator*\ s. La forma de implementarlo es la más simple.
 Todas las operaciones sobre el recolector que se llaman externamente están
 sincronizadas utilizando un *lock* global (excepto cuando hay un solo hilo
 *mutator*, en cuyo caso se omite la sincronización). Esto afecta también a la
 Todas las operaciones sobre el recolector que se llaman externamente están
 sincronizadas utilizando un *lock* global (excepto cuando hay un solo hilo
 *mutator*, en cuyo caso se omite la sincronización). Esto afecta también a la
-asignación de memoria.
+asignación de memoria y cualquier otro servicio provisto por el recolector.
 
 
 
 
 
 
@@ -1411,9 +1417,9 @@ podrían aplicarse a D_ y otras que no (como *pointer reversal*) [JOLI96]_. El
 recolector actual, sin embargo, cambia complejidad en espacio por complejidad
 en tiempo, utilizando un algoritmo iterativo que es constante (:math:`O(1)`)
 en espacio, pero que requiere varias pasada sobre el *heap* en vez de una (la
 recolector actual, sin embargo, cambia complejidad en espacio por complejidad
 en tiempo, utilizando un algoritmo iterativo que es constante (:math:`O(1)`)
 en espacio, pero que requiere varias pasada sobre el *heap* en vez de una (la
-cantidad de pasadas es en el peor caso, al igual que la cantidad de
-recursiones del algoritmo recursivo, :math:`O(|Live \thickspace set|)`, pero
-cada pasada se realiza por sobre todo el *heap*).
+cantidad de pasadas en el peor caso es :math:`O(|Live \thickspace set|)`, al
+igual que la profundidad del algoritmo recursivo, pero cada pasada se realiza
+sobre todo el *heap*).
 
 
 Conjuntos de bits para indicadores
 
 
 Conjuntos de bits para indicadores
@@ -1432,6 +1438,74 @@ utiliza conjuntos de bits. Esto trae dos ventajas principales:
   considerablemente la fase de marcado.
 
 
   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. Está implementado reservando un poco más de
+   memoria de la que pide el usuario y devolviendo un puntero a un bloque
+   ubicado dentro del bloque real reservado (en vez de al inicio). Escribiendo
+   un patrón de bits en los extremos del bloque real (ver figura
+   :vref:`fig:sentinel`) se puede verificar, en distintas situaciones (como
+   por ejemplo al barrer el bloque), que esas guardas con los patrones de bits
+   estén intactas (en caso contrario se ha escrito por fuera de los límites
+   del bloque solicitado). Esto permite detectar de forma temprana errores
+   tanto en el recolector como en el programa del usuario.
+
+   .. flt:: 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:
 
@@ -1445,6 +1519,8 @@ participación y observación del grupo de noticias, de donde se obtuvieron los
 principales problemas percibidos por la comunidad que utiliza el lenguaje.
 
 
 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
 Complejidad del código y documentación
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 El análisis del código fue muy complicado debido a la falta de documentación
@@ -1459,6 +1535,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()``::
@@ -1553,8 +1631,8 @@ Se recuerda que la semántica de dicha función es la misma que la de la funció
 
 Además, como se comentó en la sección anterior, los algoritmos en la
 implementación real son considerablemente menos modulares que los presentados
 
 Además, como se comentó en la sección anterior, 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 ``fullcollect()`` son
-300 líneas de código.
+en la sección :ref:`dgc_algo`. Por ejemplo, la función ``fullcollect()`` tiene
+300 líneas de código fuente.
 
 
 Memoria *encomendada*
 
 
 Memoria *encomendada*
@@ -1564,8 +1642,8 @@ Como se comentó en la sección anterior, diferenciar entre memoria
 particular para sistemas operativos que no hacen esta distinción, al menos
 explícitamente, donde no hay ningún beneficio en realizar esta distinción).
 
 particular para sistemas operativos que no hacen esta distinción, al menos
 explícitamente, donde no hay ningún beneficio en realizar esta distinción).
 
-Incluso para Microsoft Windows, la ventaja de realizar esta distinción es
-discutible.
+Incluso para Microsoft Windows, la ventaja de realizar esta distinción debería
+ser comprobada.
 
 
 Precisión
 
 
 Precisión
@@ -1580,8 +1658,8 @@ 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
-avances al respecto.
+general por tener un recolector más preciso [NGD87831]_, pero no han habido
+avances al respecto hasta hace muy poco tiempo.
 
 Otra forma de minimizar los efectos de la falta de precisión que se ha
 sugerido reiteradamente en el grupo es teniendo la
 
 Otra forma de minimizar los efectos de la falta de precisión que se ha
 sugerido reiteradamente en el grupo es teniendo la
@@ -1592,19 +1670,22 @@ y en particular para mejorar la implementación de de arreglos asociativos.
 
 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]_
+Si bien el recolector de Tango_ tiene un soporte limitado de *referencias
+débiles* [#dgcweakref]_, el de Phobos_ no dispone de ningún soporte (por lo
+tanto no está contemplado oficialmente el lenguaje).  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
    recolector.
 
 Para cubrir esta demanda, se han implementado soluciones como biblioteca para
 
 .. [#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
    recolector.
 
 Para cubrir esta demanda, se han implementado soluciones como biblioteca para
-suplir la inexistencia de una implementación oficial [NGA9103]_.
+suplir la inexistencia de una implementación oficial [NGA9103]_ (la
+implementación de Tango_ es otro ejemplo).
 
 
-Sin embargo éstas son en general poco robustas y extremadamente dependientes
-de la implementación del recolector y, en general, presentan problemas muy
+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
 [NGD88559]_.
 sutiles [NGD88065]_. Por esta razón se ha discutido la posibilidad de incluir
 la implementación de *referencias débiles* como parte del lenguaje
 [NGD88559]_.
@@ -1618,32 +1699,31 @@ 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
 
 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
+en el recolector, para aumentar la eficiencia 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
 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).
-
-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
-objetos bajo ninguna circunstancia), no hay mayores problemas para implementar
-un recolector que de este tipo de garantías [NGD88298]_.
+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, no hay mayores
+problemas para implementar un recolector que dé 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`
@@ -1671,19 +1751,50 @@ 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.
 
 
 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 ajustarlos a las necesidades particulares
+de sus aplicaciones.
+
+
+.. _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``
+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.
 
    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
+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
    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
@@ -1697,27 +1808,314 @@ Conjuntos de bits para indicadores:
    objeto grande; lo que equivaldría al 2560 objetos de 16 bytes
    desperdiciados en bits inutilizados).
 
    objeto grande; lo que equivaldría al 2560 objetos de 16 bytes
    desperdiciados en bits inutilizados).
 
-Repetición de código:
+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.
 
    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.
 
-Uso de señales:
-   el recolector actual utiliza las señales del sistema operativo ``SIGUSR1``
+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
    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]_.
 
    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
+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
    *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*.
 
 
+
+.. _dgc_via:
+
+Análisis de viabilidad
+----------------------------------------------------------------------------
+
+Ya conociendo el lenguaje de programación D_ (con sus necesidades
+particulares), el estado del arte en recolección de basura  y el recolector
+actual de D_ es posible evaluar la viabilidad de los distintos algoritmos
+vistos en el capítulo :ref:`gc`. Se recuerda que dentro del análisis de
+viabilidad de considera de gran importancia la viabilidad social y política de
+la mejora, es decir, se presta particular atención en encontrar una mejora que
+tenga una buena probabilidad de ser aceptada por la comunidad de D_.
+
+
+.. _dgc_via_classic:
+
+Algoritmos clásicos
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+En esta sección se presenta un análisis de los :ref:`algoritmos clásicos
+<gc_classic>`, de forma de poder analizar a grandes rasgos las principales
+familias para ir determinando la dirección principal de la solución.
+
+
+.. _dgc_via_rc:
+
+Conteo de referencias
+^^^^^^^^^^^^^^^^^^^^^
+Ya se ha propuesto en el pasado la utilización de conteo de referencias en D_
+pero no se ha demostrado un interés real, más allá de soluciones en
+bibliotecas [NGD38689]_. Las razones para no utilizar conteo de referencia son
+más o menos las mismas que las desventajas mencionadas en la sección
+:ref:`gc_rc` (en el capítulo :ref:`gc`), siendo la principal la incapacidad de
+recolectar ciclos. Sin embargo hay otras razones importantes.
+
+Una de ellas es la inter-operatividad con C. El utilizar un contador de
+referencias requiere la manipulación del contador por parte del código C con
+el que se interactúe. Si bien este problema ya está presente si código
+C guarda en su *headp* un puntero a un objeto almacenado en el *heap* del
+recolector de D_, esto es poco común. Sin embargo, mientras que una función de
+C se está ejecutando, es extremadamente común que pueda almacenar en el
+*stack* una referencia a un objeto de D_ y en ese caso el recolector actual
+puede manejarlo (mientras la función de C esté corriendo en un hilo creado por
+D_). Sin embargo al usar un conteo de referencias esto es más problemático, ya
+que no se mantiene la invariante del algoritmo si no son actualizados siempre
+los contadores.
+
+Otro problema es que al liberarse una celda, existe la posibilidad de tener
+que liberar todo el sub-grafo conectado a ésta. Cuando este sub-grafo es
+grande, se puede observar una gran pausa.
+
+Si bien estas razones son suficientes como para considerar que el conteo de
+referencias no es un algoritmo que sea viable en D_, hay muchas técnicas
+y optimizaciones para minimizarlas (como liberación perezosa, conteo de
+referencias pospuesto, etc. [JOLI96]_). Sin embargo hay otra razón importante
+que descarta esta familia de algoritmos ya que todas las variaciones de conteo
+de referencias implican, en mayor o menor medida, el entrelazado del trabajo
+del recolector con el del *mutator*. Si bien esta es una característica en
+general muy deseable (porque hace que el recolector sea :ref:`incremental
+<gc_inc>`), en D_ no lo es porque tiene como requerimiento no hacer pagar el
+precio de cosas que no se usan. En D_ debe ser posible no utilizar el
+recolector de basura y, al no hacerlo, no tener ningún tipo de trabajo extra
+asociado a éste. De usarse conteo de referencias esto no sería posible.
+
+Si bien este requerimiento puede ser discutible técnicamente, hay una gran
+resistencia social y política ante cualquier tipo de recolector que imponga
+una penalización de rendimiento a alguien que no quiera usarlo [NGD38689]_.
+Además requiere un cambio complejo y profundo en el compilador, siendo éste
+uno de los eslabones con mayor resistencia a introducir cambios.
+
+Por lo tanto se concluye que el conteo de referencias no es un algoritmo
+viable para este trabajo.
+
+
+.. _dgc_via_mark_sweep:
+
+Marcado y barrido
+^^^^^^^^^^^^^^^^^
+El marcado y barrido es un algoritmo evidentemente viable debido a que es la
+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
+<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
+D_ en cuanto a recolección de basura (ver :ref:`dgc_needs`), por ejemplo
+permite recolectar de forma conservativa, no impone un *overhead* a menos que
+se utilice el recolector, permite liberar memoria manualmente, se adapta de
+forma simple para soportar punteros *interiores* y permite finalizar objetos
+(con las limitaciones mencionadas en :ref:`dgc_prob_final`).
+
+Sin embargo muchas de las limitaciones del recolector actual (ver
+:ref:`dgc_bad`), no son inherentes al marcado y barrido, por lo que aún
+conservando la base del algoritmo, es posible realizar una cantidad de mejoras
+considerable.
+
+Una de las principales mejoras que pueden realizarse es hacer al recolector
+:ref:`concurrente <gc_concurrent>` y 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*.
+
+Más adelante veremos detalles sobre algunos de estos aspectos y sobre algunos
+algoritmos particulares que permiten hacer concurrente al recolector actual.
+
+
+Copia de semi-espacio
+^^^^^^^^^^^^^^^^^^^^^
+La copia de semi-espacio, al igual que cualquier otro tipo de recolector con
+movimiento, requiere (en la mayoría de los casos) disponer de una
+:ref:`precisión <gc_conserv>` casi completa. Las celdas para las cuales hay
+alguna referencia que no es precisa no pueden ser movidas, ya que al no estar
+seguros que la referencia sea tal, ésta no puede ser actualizada con la
+dirección de la nueva ubicación de la celda movida porque de no ser una
+referencia se estarían alterando datos del usuario, corrompiéndolos.
+
+Es por esto que si el recolector no es mayormente preciso, las celdas que
+pueden ser movidas son muy pocas y, por lo tanto, se pierden las principales
+ventajas de esta familia de recolectores (como la capacidad de asignar nueva
+memoria mediante *pointer bump allocation*).
+
+Este aumento de precisión, sin embargo, es bastante realizable. Es posible, en
+teoría, hacer que al menos el *heap* sea preciso, aunque es discutible si en
+la práctica es aceptable el *overhead* en espacio necesario para almacenar la
+información del tipo de una celda. Esto se analiza en más detalle al evaluar
+la recolección precisa en la siguiente sección.
+
+Si bien las principales herramientas para que sea viable un recolector por
+copia de semi-espacio están disponibles en D_ (como la posibilidad de hacer
+*pinning* the celdas o el potencial incremento de precisión), este lenguaje
+nunca va a poder proveer precisión total, haciendo que no sea posible
+implementar un recolector por copia de semi-espacio puro. Siempre habrá que
+disponer un esquema híbrido para poder manejar las celdas que no puedan
+moverse, incrementado mucho la complejidad del recolector.
+
+Si bien un esquema híbrido es algo técnicamente posible, nuevamente la
+resistencia social a un cambio de esta envergadura es de importancia
+suficiente como para inclinarse por una solución menos drástica.
+
+
+.. _dgc_via_art:
+
+Principales categorías del estado del arte
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+En esta sección se realiza un análisis de la viabilidad de las principales
+categorías de recolectores según se presentaron en la sección :ref:`gc_art`.
+
+Recolección directa / indirecta
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Como se ha visto al analizar el conteo de referencias, lo más apropiado para
+D_ pareciera ser continuar con el esquema de recolección indirecta, de forma
+tal de que el precio de la recolección solo deba ser pagado cuando el
+*mutator* realmente necesita del recolector. Es por esto que no parece ser una
+opción viable introducir recolección directa en este trabajo.
+
+
+Recolección incremental
+^^^^^^^^^^^^^^^^^^^^^^^
+La recolección incremental puede ser beneficiosa para D_, dado que puede
+servir para disminuir el tiempo de pausa del recolector. Sin embargo, en
+general es necesario instrumentar el *mutator* para reportar cambios en el
+grafo del conectividad al recolector. Además puede contar con los mismos
+problemas que la recolección directa, puede hacer que el usuario tenga que
+pagar el precio de la recolección, incluso cuando no la necesita, si por cada
+asignación el recolector realiza parte de una recolección que no fue
+solicitada.
+
+Recolección concurrente / paralela / *stop-the-world*
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+El recolector actual es *stop-the-world*, sin embargo esta es una de las
+principales críticas que tiene. El recolector se podría ver beneficiado de
+recolección paralela, tanto para realizar la recolección más velozmente en
+ambientes *multi-core*, como para disminuir el tiempo de pausa, un factor muy
+importante para programas que necesiten tener baja latencia, como programas
+*real-time*.
+
+En general los recolectores concurrentes necesitan también instrumentar el
+*mutator* para reportar cambios en el grafo de conectividad al recolector,
+como sucede con la recolección directa o incremental, sin embargo hay
+algoritmos que no tienen este requerimiento, utilizando servicios del sistema
+operativo para tener una *fotografía* de la memoria para que la fase de
+marcado pueda realizarse sin perturbar al *mutator* ni requerir de su
+cooperación [RODR97]_. Este tipo de algoritmos serían un buen candidato para
+D_, dado que requiere pocos cambios y es transparente al *mutator*.
+
+
+Recolección conservativa / precisa
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Si bien D_ puede proveer al recolector de basura información de tipos para los
+objetos almacenados en el *heap*, todo recolector para D_ deberá soportar
+cierto grado de recolección conservativa (ver :ref:`gc_conserv`), debido a las
+siguientes razones:
+
+* Si bien D_ podría incorporar información de tipos para el *stack*
+  (utilizando, por ejemplo, la técnica de *shadow stack* [HEND02]_), para
+  poder interactuar con C/C++, el recolector debe poder interpretar los *stack
+  frames* [#dgcstackframe]_ de estos lenguajes, que no disponen de información
+  de tipos.
+
+* Los registros del procesador tienen un problema similar, con la diferencia
+  de que el costo de implementar algo similar a *shadow stack* para los
+  registros sería impracticable, más allá de que exista la misma limitación
+  que con el *stack* para poder interactuar con C/C++.
+
+* D_ soporta uniones (ver :ref:`d_low_level`). Para una unión es imposible
+  determinar si un campo es un puntero o no. Por ejemplo::
+
+      union U {
+         size_t x;
+         void* p;
+      }
+
+  Aquí el recolector no puede saber nunca si el valor almacenado será un
+  ``size_t`` o un ``void*``, por lo tanto deberá tratar **siempre** esa
+  palabra de forma conservativa (es decir, interpretarla como un *posible*
+  puntero). Este requerimiento puede ser relajado si el usuario proveyera
+  alguna forma de determinar que tipo está almacenando la unión en un
+  determinado momento. Sin embargo el costo de pedir al usuario este tipo de
+  restricción puede ser muy alto.
+
+Durante el desarrollo de este trabajo se encontra un trabajo relacionado
+avanzando en este sentido, que agrega precisión al marcado del *heap*. David
+Simcha comienza explorando la posibilidad de agregar precisión parcial al
+recolector, generando información sobre la ubicación de los punteros para cada
+tipo [DBZ3463]_. Su trabajo se limita a una implementación a nivel biblioteca
+de usuario y sobre `D 2.0`_.  Desafortunadamente su trabajo pasa desapercibido
+por un buen tiempo.
+
+Sin embargo un tiempo después Vincent Lang (mejor conocido como *wm4* en la
+comunidad de D_), retoma este trabajo, pero modificando el compilador DMD_
+y trabajando con `D 1.0`_ y Tango_. Es por esto que el aumento de precisión
+parece ser un área fértil para este trabajo, en particular si se colabora con
+el trabajo realizado por David y Vincent.
+
+.. [#dgcstackframe] Un *stack frame* (*marco de la pila* en castellano),
+   también conocido como *activation record* (o *registro de activación* en
+   castellano) es una estructura de datos dependiente de la arquitectura que
+   contiene información del estado de una función, incluyendo, por ejemplo,
+   sus variables locales, parámetros y dirección de retorno.
+
+
+Recolección con movimiento de celdas
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Esta posibilidad ya se ha discutido al analizar la posibilidad de utilizar
+recolección con copia de semi-espacios. El trabajo mencionado en la sub-sección
+anterior agrega información suficiente como poder diferenciar que celdas se
+pueden mover y cuales no, sin embargo queda como incógnita qué proporción de
+celdas deben permanecer inmovilizadas como para evaluar si un cambio tan
+grande puede rendir frutos o no.
+
+A priori, pareciera que la relación cantidad y complejidad de cambios sobre
+beneficios potenciales no fuera muy favorable a esta mejora.
+
+
+Lista de libres / *pointer bump allocation*
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Como consecuencia de los puntos anteriores, no es técnicamente posible
+realizar *pointer bump allocation* pura en D_. Al haber objetos *pinned*,
+siempre es necesario o bien contar con una lista de libres, o detectar
+*huecos* en un esquema de *pointer bump allocation*. Es por esto que parece
+ser más viable conservar el esquema de listas de libres.
+
+Esta mejora también entra en la categoría de opciones viables pero cuya
+complejidad no parece valer la pena dada la limitada utilidad que se espera
+dadas las particulares características de D_ en cuanto a precisión de
+información de tipos de *stack*, uniones, etc.
+
+
+Recolección por particiones / generacional
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Una vez más la recolección por particiones, en particular la generacional,
+requiere de la instrumentación del *mutator* para comunicar cambios en el
+grafo de conectividad al recolector, por lo que es poco viable. Aunque existen
+algoritmos que no necesitan este tipo de comunicación dado que está
+garantizado que no existan conexiones entre celdas de las distintas
+particiones, requiere grandes cambios en el compilador y realizar análisis
+estático bastante complejo [HIRZ03]_. Además al ser D_ un lenguaje de bajo
+nivel, es muy difícil garantizar que estas conexiones inter-particiones no
+puedan existir realmente; y de hacerlo, podría ser demasiado restrictivo.
+
+
 .. include:: links.rst
 
 .. vim: set ts=3 sts=3 sw=3 et tw=78 spelllang=es :
 .. include:: links.rst
 
 .. vim: set ts=3 sts=3 sw=3 et tw=78 spelllang=es :