Corregir ortografía, errores de tipeo, etc.

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

diff --git a/source/dgc.rst b/source/dgc.rst
index a0b9ce525b8b6a8f195f06210e32760ee914d4f3..4d91f8ea18e3c89f77cbbbe5fbf588209787bfa6 100644 (file)
--- a/source/dgc.rst
+++ b/source/dgc.rst
@@ -4,7 +4,7 @@
    de recolección de basura en dicho lenguaje (se explica por qué las
    particularidades descriptas en la sección anterior complican la
    recolección de basura y cuales son las que más molestan).
    de recolección de basura en dicho lenguaje (se explica por qué las
    particularidades descriptas en la sección anterior complican la
    recolección de basura y cuales son las que más molestan).

-   ESTADO: SIN EMPEZAR, REVISAR LO HECHO
+   ESTADO: TERMINADO, CORREGIDO

 
 
 .. _dgc:
 
 
 .. _dgc:


@@ -12,14 +12,160 @@
 Recolección de basura en D
 ============================================================================
 
 Recolección de basura en D
 ============================================================================
 

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

 
 

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

 
 

-Dificultades para recolectar basura en D
+
+
+.. _dgc_needs:
+
+Características y necesidades particulares de D_

 ----------------------------------------------------------------------------
 
 ----------------------------------------------------------------------------
 

-TODO
+En esta sección se hará un recorrido por las características y necesidades
+particulares que tiene D_ como lenguaje con respecto a la recolección de
+basura.
+
+
+
+.. _dgc_prob_low_level:
+
+Programación de bajo nivel (*system programming*)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Sin dudas las características de D_ que lo hacen más complejo a la hora de
+implementar un recolector de basura son sus capacidades de programación de
+bajo nivel (ver :ref:`d_low_level`).
+
+Al proveer acceso a *aasembly*, permitir estructuras de tipo *union* y ser
+compatible con C/C++, el recolector de basura tiene muchas restricciones. Por
+ejemplo debe tratar de forma conservativa los registros y el *stack*, ya que
+es la única forma de interactuar de forma segura con C/C++ y *assembly*.
+
+Además debe poder interactuar con manejo de memoria explícito, ya sea
+omitiendo por completo el *heap* del recolector o liberando explícitamente
+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
+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.
+
+
+
+.. _d_prob_high_level:
+
+Programación de alto nivel
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Las características de programación de alto nivel también impone dificultades
+o restricciones al recolector de basura (ver :ref:`d_high_level`). Por ejemplo
+el soporte de rebanado (*slicing*) de arreglos hace que el recolector deba
+soportar punteros *interiores* [#dgcinterior]_ (esto también es necesario
+porque en general en D_ o en cualquier lenguaje de bajo nivel se puede tener
+un puntero a cualquier parte de una celda).
+
+.. [#dgcinterior] Los punteros *interiores* son aquellos que en vez de apuntar
+   al inicio de una celda, apuntan a una dirección arbitraria dentro de ella.
+   Esto no es posible en muchos lenguajes de programación, como por ejemplo
+   Java_, lo que simplifica la recolección de basura.
+
+Los arreglos dinámicos y asociativos en particular dependen fuertemente del
+recolector de basura, en particular cuando se agregan elementos (o se
+concatenan dos arreglos).
+
+Dado que los *strings* son arreglos dinámicos y que el lenguaje provee un buen
+soporte de arreglos dinámicos y asociativos y *slicing*, es de esperarse que
+el recolector deba comportarse de forma correcta y eficiente ante las
+operaciones más típicas de estas estructuras que dependan de él.
+
+
+
+.. _dgc_prob_types:
+
+Información de tipos
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Hasta aquí D_ comparte todas las restricciones con respecto a la recolección
+de basura con los lenguajes de bajo nivel que no tienen ningún soporte para
+recolectar basura. Sin embargo, a diferencia de éstos, D_ tiene una
+información de tipos más rica. Al momento de asignar memoria D_ puede proveer
+cierta información sobre el objeto a asignar (como si puede contener punteros
+o no) que puede ser utilizada por el recolector para realizar una recolección
+más precisa (ver :ref:`gc_conserv`).
+
+En general esta información no es suficiente como para implementar un
+recolector completamente preciso (no al menos sin agregar un mejor soporte de
+reflexión al lenguaje) pero puede ser de ayuda considerable para el
+recolector.
+
+
+
+.. _dgc_prob_final:
+
+Orientación a objetos y finalización
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+D_ soporta el paradigma de orientación a objetos, donde es común permitir que
+un objeto, al ser destruido, realice alguna tarea de finalización (a través de
+una función miembro llamada *destructor*, o ``~this()`` en D_). Esto significa
+que el recolector, al encontrar que no hay más referencias a un objeto, debe
+ejecutar el destructor.
+
+La especificación dice:
+
+   The garbage collector is not guaranteed to run the destructor for all
+   unreferenced objects. Furthermore, the order in which the garbage collector
+   calls destructors for unreference objects is not specified. This means that
+   when the garbage collector calls a destructor for an object of a class that
+   has members that are references to garbage collected objects, those
+   references may no longer be valid. This means that destructors cannot
+   reference sub objects.
+
+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
+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.
+
+Esta restricción en realidad se ve relaja con el soporte de *RAII*. Si se
+utiliza la palabra clave ``scope`` al crear una serie de objetos, estos serán
+destruidos determinísticamente al finalizar el *scope* actual en el orden
+inverso al que fueron creados y, por lo tanto, un usuario podría hacer uso de
+los atributos que sean referencias a otros objetos creados con ``scope`` si el
+orden en que fueron creados (y por lo tanto en que serán destruidos) se lo
+permite.
+
+Sin embargo no hay forma actualmente de saber dentro de un destructor si este
+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
+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
+garantías que provee la implementación actual la comunidad de D_ cuenta con
+ellas porque además son deseables (y sencillas de implementar).

 
 
 
 
 
 


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

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

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


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

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

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


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

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

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


@@ -196,7 +342,7 @@ Cada *pool* tiene la siguiente información asociada:
    *pool*.
 
 *pages*:
    *pool*.
 
 *pages*:

-   bloque de memoria contíguo de tamaño ``PAGE_SIZE * number_of_pages``
+   bloque de memoria contiguo de tamaño ``PAGE_SIZE * number_of_pages``

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


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

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

 significado especial:
 
 ``FREE``:
 significado especial:
 
 ``FREE``:


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

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

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


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

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

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


@@ -336,7 +482,7 @@ pausan y reanudan todos los hilos respectivamente::
       foreach thread in threads
          thread.resume()
 
       foreach thread in threads
          thread.resume()
 

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

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


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

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

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


@@ -394,9 +540,9 @@ los threads para terminar de marcar el *root set*::
 Dado que D_ soporta manejo de memoria manual al mismo tiempo que memoria
 automática, es posible que existan celdas de memoria que no estén en el *root
 set* convencional ni en el *heap* del recolector. Para evitar que se libere
 Dado que D_ soporta manejo de memoria manual al mismo tiempo que memoria
 automática, es posible que existan celdas de memoria que no estén en el *root
 set* convencional ni en el *heap* del recolector. Para evitar que se libere

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

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


@@ -442,12 +588,12 @@ celdas para visitar (con el bit *scan* activo)::
                               mark(pointer)
 
 Aquí puede verse, con un poco de esfuerzo, la utilización de la
                               mark(pointer)
 
 Aquí puede verse, con un poco de esfuerzo, la utilización de la

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

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

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

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


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

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

 *interiores*.
 
 
 *interiores*.
 
 


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

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

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


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

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

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


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

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

 
       function new_small(block_size) is
          block = find_block_with_size(block_size)
 
       function new_small(block_size) is
          block = find_block_with_size(block_size)


@@ -685,7 +831,7 @@ grande::
          return pages[0]
 
 De forma similar a la asignación de objetos pequeños, se intenta encontrar una
          return pages[0]
 
 De forma similar a la asignación de objetos pequeños, se intenta encontrar una

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

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


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

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

 
       function find_pages(number_of_pages) is
          foreach pool in heap
 
       function find_pages(number_of_pages) is
          foreach pool in heap


@@ -716,7 +862,7 @@ contíguas se utiliza el siguiente algoritmo::
          return null
 
 Como se dijo, las páginas deben estar contenidas en un mismo *pool* (para
          return null
 
 Como se dijo, las páginas deben estar contenidas en un mismo *pool* (para

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

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


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

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

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


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

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

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


@@ -862,7 +1008,7 @@ facilitar la comprensión):
       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

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

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


@@ -958,7 +1104,7 @@ La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura
 Como se observa, además de la información particular del *pool* se almacena
 toda la información de páginas y bloques enteramente en el *pool* también.
 Esto simplifica el manejo de que lo es memoria *pura* del *heap*, ya que queda
 Como se observa, además de la información particular del *pool* se almacena
 toda la información de páginas y bloques enteramente en el *pool* también.
 Esto simplifica el manejo de que lo es memoria *pura* del *heap*, ya que queda

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

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


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

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

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

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

 
 A continuación se resumen las funciones principales, separadas en categorías
 para facilitar la comprensión. Los siguientes son métodos de la estructura
 
 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


@@ -1157,17 +1303,17 @@ para facilitar la comprensión. Los siguientes son métodos de la estructura
       guarda los registros en el *stack* y llama a ``fullcollect()``. El
       algoritmo presentado en :ref:`dgc_algo_mark` es simbólico, ya que si los
       registros se apilaran en el *stack* dentro de otra función, al salir de
       guarda los registros en el *stack* y llama a ``fullcollect()``. El
       algoritmo presentado en :ref:`dgc_algo_mark` es simbólico, ya que si los
       registros se apilaran en el *stack* dentro de otra función, al salir de

-      esta se volverían a desapilar, por lo tanto debe ser hecho en la misma
+      esta se volverían a des-apilar, por lo tanto debe ser hecho en la misma

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

-      realiza la recolección de basura. Es análoga a ``collect()`` pero
-      considerablemente menos modularizada, todos los pasos se hacen
-      directamente en esta función: marcado del *root set*, marcado iterativo
-      del *heap*, barrido y reconstrucción de la lista de libres. Además
-      devuelve la cantidad de páginas que se liberaron en la recolección, lo
-      que permite optimizar levemente la función ``bigAlloc()``.
+      realiza la recolección de basura. Es análoga a ``collect()`` pero es
+      considerablemente menos modular, todos los pasos se hacen directamente
+      en esta función: marcado del *root set*, marcado iterativo del *heap*,
+      barrido y reconstrucción de la lista de libres. Además devuelve la
+      cantidad de páginas que se liberaron en la recolección, lo que permite
+      optimizar levemente la función ``bigAlloc()``.

 
 
 Finalización
 
 
 Finalización


@@ -1186,7 +1332,7 @@ y proveer finalización asegurada puede ser muy deseable.
 Memoria *encomendada*
 ^^^^^^^^^^^^^^^^^^^^^
 El algoritmo actual divide un *pool* en dos áreas: memoria *encomendada*
 Memoria *encomendada*
 ^^^^^^^^^^^^^^^^^^^^^
 El algoritmo actual divide un *pool* en dos áreas: memoria *encomendada*

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

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


@@ -1222,14 +1368,80 @@ asignación de memoria.
 
 
 
 
 
 

-.. _dgc_problems:
+.. _dgc_good:
+
+Características destacadas
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Si bien el recolector en términos generales no se aleja mucho de un
+:ref:`marcado y barrido clásico <gc_mark_sweep>`, tiene algunas mejoras por
+sobre el algoritmo más básicos que vale la pena destacar:
+
+
+Organización del *heap*
+^^^^^^^^^^^^^^^^^^^^^^^
+El *heap* está organizado de una forma que, si bien no emplea las técnicas más
+modernas que pueden observarse en el estado del arte (como :ref:`regiones
+<gc_free_list>`), es relativamente sofisticada. El esquema de *pools*
+y bloques permite disminuir considerablemente los problemas de *fragmentación*
+de memoria y evita búsquedas de *huecos* que pueden ser costosas (como
+*best-fit* [#dgcbestfit]_) o desperdiciar mucho espacio (como *first-fit*
+[#dgcfirstfit]_), logrando un buen equilibrio entre velocidad y espacio
+desperdiciado.
+
+.. [#dgcbestfit] Las búsquedas de tipo *best-fit* son aquellas donde se busca
+   el *hueco* en el *heap* (es decir, una región contínua de memoria
+   libre) que mejor se ajuste al tamaño del objeto a asignar. Es decir, el
+   *hueco* más pequeño lo suficientemente grande como para almacenarlo.
+
+.. [#dgcfirstfit] Las búsquedas de tipo *first-fit* son aquellas donde se busca
+   el primer *hueco* en el *heap* (es decir, una región contínua de memoria
+   libre) que sea lo suficientemente grande como para almacenar el objeto
+   a asignar.
+
+
+Fase de marcado iterativa
+^^^^^^^^^^^^^^^^^^^^^^^^^
+A diferencia del algoritmo clásico recursivo, el algoritmo del recolector
+actual es iterativo. El algoritmo recursivo tiene un problema fundamental: se
+puede llegar a un desbordamiento de pila (o *stack overflow*). La cantidad de
+recursiones necesarias es, en el peor caso, :math:`O(|Live \thickspace set|)`
+(por ejemplo, si todas las celdas del *heap* formaran una lista simplemente
+enlazada). Hay muchas técnicas para lidiar con este problema, algunas que
+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*).
+
+
+Conjuntos de bits para indicadores
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+El algoritmo clásico propone almacenar en la propia celda la marca (para la
+fase de marcado) y otros indicadores. El algoritmo del recolector actual
+utiliza conjuntos de bits. Esto trae dos ventajas principales:
+
+* Permite minimizar el espacio requerido, ya que de otra forma en general se
+  desperdicia una palabra entera como cabecera de celda para guardar este tipo
+  de información.
+
+* Mejora la localidad de referencia, ya que los indicadores se escriben de
+  forma muy compacta y en una región de memoria contigua que generalmente
+  puede entrar en el cache o en pocas páginas de memoria acelerando
+  considerablemente la fase de marcado.
+
+
+
+.. _dgc_bad:

 
 Problemas y limitaciones
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 A continuación se presentan los principales problemas encontrados en la
 implementación actual del recolector de basura de D_. Estos problemas surgen
 
 Problemas y limitaciones
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 A continuación se presentan los principales problemas encontrados en la
 implementación actual del recolector de basura de D_. Estos problemas surgen

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

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


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

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

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


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

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

 
 
 Memoria *encomendada*
 
 
 Memoria *encomendada*


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

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

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

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

 esporádicamente [NGD54084]_ [NGL13744]_.
 
 De todas maneras queda mucho lugar para mejoras, y es un tema recurrente en el
 grupo de noticias de D_ y se han discutido formas de poder hacer que, al menos
 esporádicamente [NGD54084]_ [NGL13744]_.
 
 De todas maneras queda mucho lugar para mejoras, y es un tema recurrente en el
 grupo de noticias de D_ y se han discutido formas de poder hacer que, al menos

-el *heap* sea preciso [NGD44607]_ [NGD29291]_. Además se mostro un interés
+el *heap* sea preciso [NGD44607]_ [NGD29291]_. Además se mostró un interés

 general por tener un recolector más preciso [NGDN87831]_, pero no han habido
 avances al respecto.
 
 general por tener un recolector más preciso [NGDN87831]_, pero no han habido
 avances al respecto.
 


@@ -1412,7 +1624,7 @@ memoria [NGD75952]_ [NGDN87831]_.
 Además se ha mostrado un interés por tener un nivel de concurrencia aún mayor
 en el recolector, para aumentar la concurrencia en ambientes *multi-core* en
 general pero en particular para evitar grandes pausas en programas con
 Además se ha mostrado un interés por tener un nivel de concurrencia aún mayor
 en el recolector, para aumentar la concurrencia en ambientes *multi-core* en
 general pero en particular para evitar grandes pausas en programas con

-requerimientos de tiempo real, historicamente una de las principales críticas
+requerimientos de tiempo real, históricamente una de las principales críticas

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


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

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

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

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

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

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

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

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

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


@@ -1466,26 +1678,28 @@ Finalmente hay varios detalles en la implementación actual que podrían
 mejorarse:
 
 Listas de libres:
 mejorarse:
 
 Listas de libres:

-  hay 12 listas de libres, como para guardar bloques de tamaño de ``B_16``
-  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:
-  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*. Como un *pool* tiene páginas con distintos tamaños de
-  bloque, se reserva una cantidad de bits igual a la mayor cantidad posible de
-  bloques que puede haber en el *pool*; es decir, se reserva 1 bit por cada 16
-  bytes del *pool*. Para un *pool* de 1 MiB (tamaño mínimo), teniendo en
-  cuenta que se utilizan 5 conjuntos de bits (``mark``, ``scan``, ``finals``,
-  ``freebits`` y ``noscan``), se utilizan 40 KiB de memoria para conjuntos de
-  bits (un 4% de *desperdicio* si, por ejemplo, ese *pool* estuviera destinado
-  por completo a albergar un solo objeto grande; lo que equivaldría al 2560
-  objetos de 16 bytes desperdiciados en bits inutilizados).
+   hay 12 listas de libres, como para guardar bloques de tamaño de ``B_16``
+   a ``B_2048``, ``B_PAGE``, ``B_PAGEPLUS``, ``B_UNCOMMITTED`` y ``B_FREE``;
+   sin embargo solo tienen sentido los bloques de tamaño ``B_16``
+   a ``B_2048``, por lo que 4 de esas listas no se utilizan.
+
+Conjuntos de bits para indicadores:
+   los indicadores para la fase de marcado y otras propiedades de un bloque
+   son almacenados en conjuntos de bits que almacenan los indicadores de todos
+   los bloques de un *pool*. Si bien se ha mencionado esto como una ventaja,
+   hay lugar todavía como para algunas mejoras. Como un *pool* tiene páginas
+   con distintos tamaños de bloque, se reserva una cantidad de bits igual a la
+   mayor cantidad posible de bloques que puede haber en el *pool*; es decir,
+   se reserva 1 bit por cada 16 bytes del *pool*. Para un *pool* de 1 MiB
+   (tamaño mínimo), teniendo en cuenta que se utilizan 5 conjuntos de bits
+   (``mark``, ``scan``, ``finals``, ``freebits`` y ``noscan``), se utilizan 40
+   KiB de memoria para conjuntos de bits (un 4% de *desperdicio* si, por
+   ejemplo, ese *pool* estuviera destinado por completo a albergar un solo
+   objeto grande; lo que equivaldría al 2560 objetos de 16 bytes
+   desperdiciados en bits inutilizados).

 
 Repetición de código:
 
 Repetición de código:

-   Hay algunos fragmentos de código repetidos inecesariamente. Por ejemplo en
+   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
    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


@@ -1494,10 +1708,16 @@ Repetición de código:
 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
 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 incovenientes a usuarios que desean utilizar estas
+   puede traer inconvenientes a usuarios que desean utilizar estas

    señales en sus programas (o peor aún, si interactúan con bibliotecas
    de C que hacen uso de estas señales) [NGD5821]_.
 
    señales en sus programas (o peor aún, si interactúan con bibliotecas
    de C que hacen uso de estas señales) [NGD5821]_.
 

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

 
 .. include:: links.rst
 
 
 .. include:: links.rst