X-Git-Url: https://git.llucax.com/z.facultad/75.00/informe.git/blobdiff_plain/b65eb55993530f30dea2f032b4d1b0611a24f2fc..refs/heads/master:/source/dgc.rst

diff --git a/source/dgc.rst b/source/dgc.rst
index 654bb52..497e20e 100644
--- a/source/dgc.rst
+++ b/source/dgc.rst
@@ -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
-
-
 .. _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
-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
-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.
 
-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.
@@ -142,7 +135,7 @@ La especificación dice [DWDE]_:
 
 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.
@@ -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.
 
-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``.
 
-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.
-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
-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
-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
-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
@@ -296,13 +288,13 @@ 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.
 
 .. flt:: fig:dgc-free-list
 
@@ -357,17 +349,17 @@ Una página siempre almacena bloques del mismo tamaño, que pueden ser 16, 32,
 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).
+   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
+   que ocupa dos o más páginas). Luego se presentan más detalles sobre objetos
    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.
 
 
@@ -389,8 +381,8 @@ Cada bloque tiene asociados varios atributos:
    Indica que el bloque está libre (no está siendo utilizado por ningún objeto
    *vivo*). Esto es necesario solo por la forma en la que realiza el
    :ref:`marcado <dgc_algo_mark>` y :ref:`barrido <dgc_algo_sweep>` en el
-   :ref:`algoritmo actual <dgc_algo>` (las celdas con el atributo este
-   atributo son tomadas como *basura* aunque estén marcadas con *mark*).
+   :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
@@ -398,7 +390,7 @@ Cada bloque tiene asociados varios atributos:
 
 *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*).
+   tanto no debe ser escaneado (no tiene *hijas*).
 
 
 Objetos grandes
@@ -451,7 +443,7 @@ básicas de cualquier algoritmo de :ref:`marcado y barrido <gc_mark_sweep>`::
 
 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
@@ -460,10 +452,10 @@ algoritmo::
       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()
-      pop_registers_from_stack()
+      pop_registers_from_stack(thread_self)
       mark_user_roots()
       mark_heap()
       start_the_world()
@@ -475,24 +467,30 @@ iteración se interrumpe cuando no hay más celdas por visitar.
 
 Las funciones ``stop_the_world()`` y ``start_the_world()`` pausan y reanudan
 todos los hilos respectivamente (salvo el actual). Al pausar los hilos además
-se guardan los registros del procesador en el *stack* y se guarda la posición
-actual del *stack* para que la fase de marcado pueda recorrerlos::
+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
          if thread is thread_self
             continue
          thread.pause()
-         push_registers_into_stack()
+         push_registers_into_stack(thread)
          thread.stack.end = get_stack_top()
 
    function start_the_world() is
-      foreach thread in threads
+      foreach thread in reversed(threads)
          if thread is thread_self
             continue
-         pop_registers_from_stack()
+         pop_registers_from_stack(thread)
          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*::
 
@@ -511,7 +509,7 @@ tiempo sin sentido y potencialmente manteniendo *vivas* celdas que en
 realidad son *basura* (*falsos positivos*)::
 
    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
@@ -533,15 +531,16 @@ Primero se marca el área de memoria estática de manera :ref:`conservativa
 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)
 
-Y luego se descartan (no es necesario ni correcto restablecer los valores ya
-que podrían tener nuevos valores) al sacarlos de la pila::
+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() is
-      foreach register in reverse(registers)
+   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
@@ -629,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]
-            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
@@ -687,14 +686,14 @@ 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
-      foreach free_list in heap
+      foreach free_list in free_lists
          free_list.clear()
       foreach pool in heap
          foreach page in pool
@@ -784,9 +783,10 @@ Para intentar buscar un bloque de memoria libre se realiza lo siguiente::
          block = free_lists[block_size].pop_first()
       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
@@ -824,7 +824,7 @@ 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
-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::
 
    function new_big(size) is
@@ -951,10 +951,10 @@ Detalles de implementación
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Hay varias diferencias a nivel de implementación entre lo que se presentó en
-las secciones anteriores y como está implementado realmente el recolector
-actual. Con los conceptos e ideas principales del ya explicadas, se procede
-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_.
 
@@ -986,7 +986,7 @@ Estado interno del recolector
       <gc_intro_tricolor>`). Es análoga a la variable ``more_to_scan``
       presentada en :ref:`dgc_algo_mark`.
 
-   *inited*
+   *inited* (sic)
       Indica si el recolector fue inicializado.
 
    *stackBottom*
@@ -1025,11 +1025,11 @@ Atributos que cambian el comportamiento
 
 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é*.
+      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
@@ -1052,7 +1052,8 @@ 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
-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
@@ -1086,7 +1087,7 @@ La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura
    secciones anteriores para mayor claridad).
 
 *mark*, *scan*, *freebits*, *finals*, *noscan*
-   Conjunto de bits (*bitsets*) para almacenar los indicadores descriptos en
+   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.
@@ -1112,7 +1113,7 @@ La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura
 
 Como se observa, además de la información particular del *pool* se almacena
 toda la información de páginas y bloques enteramente en el *pool* también.
-Esto simplifica el manejo de que lo es memoria *pura* del *heap*, ya que queda
+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.
 
@@ -1133,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
-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.
 
@@ -1148,7 +1149,7 @@ 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
-``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
@@ -1172,7 +1173,7 @@ Manipulación de raíces definidas por el usuario
       Agrega, remueve e itera sobre los rangos de raíces definidas por el
       usuario.
 
-Manipulación de indicadores
+Manipulación de bits indicadores
    *getBits(pool, biti)*
       Obtiene los indicadores especificados para el bloque de índice ``biti``
       en el *pool* ``pool``.
@@ -1302,12 +1303,11 @@ Recolección
       presentado en la sección :ref:`dgc_algo_mark`.
 
    *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).
+      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
@@ -1338,10 +1338,10 @@ 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
@@ -1350,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
-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
@@ -1368,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
-asignación de memoria.
+asignación de memoria y cualquier otro servicio provisto por el recolector.
 
 
 
@@ -1416,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
-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
@@ -1471,14 +1472,15 @@ Las opciones más importantes son:
 
 ``SENTINEL``
    Su función detectar errores producidos por escribir más allá (o antes) del
-   área de memoria solicitada y está implementado reservando un poco más de
-   memoria de la que pide el usuario, devolviendo un puntero a un bloque
-   ubicado dentro del bloque real reservado (en vez de al inicio) y finalmente
-   escribiendo un patrón de bits en los extremos del borde real (ver figura
-   :vref:`fig:sentinel`), de forma de poder verificar en distintas situación
-   (por ejemplo al barrer el bloque) que esas áreas de más con los patrones de
-   bits estén intactas. Esto permite detectar de forma temprana errores tanto
-   en el recolector como en el programa del usuario.
+   á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
 
@@ -1629,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
-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*
@@ -1640,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).
 
-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
@@ -1657,7 +1659,7 @@ 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 [NGD87831]_, pero no han habido
-avances al respecto.
+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
@@ -1668,19 +1670,22 @@ y en particular para mejorar la implementación de de arreglos asociativos.
 
 Referencias débiles
 ^^^^^^^^^^^^^^^^^^^
-El recolector actual no dispone de soporte de *referencias débiles*
-[#dgcweakref]_, sin embargo hay una demanda apreciable [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
-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, 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]_.
@@ -1697,7 +1702,7 @@ de hilos, de manera de disminuir la contención, al menos para la asignación de
 memoria [NGD75952]_ [NGD87831]_.
 
 Además se ha mostrado un interés por tener un nivel de concurrencia aún mayor
-en el recolector, para aumentar la concurrencia en ambientes *multi-core* en
+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
 al lenguaje [NGD87831]_ [NGL3937]_ [NGD22968]_ [NGA15246]_ [NGD5622]_
@@ -1716,10 +1721,9 @@ 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]_.
+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`
@@ -1759,8 +1763,8 @@ lenguaje.
 
 Dado que es imposible que un recolector sea óptimo para todo tipo de
 programas, es muy deseable permitir una configuración de parámetros del
-recolector que permitan al usuario ajustarlo a las necesidades particulares de
-sus programas.
+recolector que permitan al usuario ajustarlos a las necesidades particulares
+de sus aplicaciones.
 
 
 .. _dgc_bad_ocup:
@@ -1826,12 +1830,6 @@ Marcado iterativo
 
 
 
-.. Esto sería muy similar a la sección de "Recolección de basura) pero en
-   vez de ir describiendo los algoritmos iría comentando por qué los tomo
-   o descarto
-   ESTADO: INCOMPLETO
-
-
 .. _dgc_via:
 
 Análisis de viabilidad
@@ -1870,9 +1868,8 @@ 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 un puntero a un objeto almacenado en el *heap* del recolector de D_
-en el *heap* de C (es decir, en una celda de memoria asignada por
-``malloc()``), esto es poco común. Sin embargo, mientras que una función de
+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
@@ -1934,10 +1931,10 @@ 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 parcialmente más :ref:`preciso
-<gc_conserv>`. Estas dos mejoras solamente alcanzarían para mejorar de forma
-notable el tiempo de pausa en las recolecciones y la cantidad de memoria
-retenida debido a *falsos positivos*.
+: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.
@@ -2010,12 +2007,9 @@ 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-procesador, como para disminuir el tiempo de pausa. Sin
-embargo, el hecho de que todos los hilos se pausen para realizar parte del
-trabajo del recolector puede ser contraproducente para programas *real-time*
-que pretendan usar un hilo que no sufra de la latencia del recolector,
-asegurando que nunca lo use (aunque se podrían ver esquemas para ajustarse
-a estas necesidades).
+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,
@@ -2061,12 +2055,12 @@ siguientes razones:
   determinado momento. Sin embargo el costo de pedir al usuario este tipo de
   restricción puede ser muy alto.
 
-Sin embargo, ya hay un trabajo relacionado avanzando en este sentido, que
-agrega precisión al marcado del *heap*. David Simcha comienza con este trabajo
-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
+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
@@ -2119,8 +2113,7 @@ 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 poder lograrlo, podría ser demasiado
-restrictivo.
+puedan existir realmente; y de hacerlo, podría ser demasiado restrictivo.
 
 
 .. include:: links.rst