.. Introducción y breve reseña del lenguaje de programación D. También
se presentan las necesidades particulares de D con respecto al
recolector de basura y su estado actual.
- ESTADO: TERMINADO
+ ESTADO: TERMINADO, CORREGIDO
.. _d_lang:
mayores problemas también.
Otra gran diferencia con C++ es la facilidad para ser analizado
-gramaticalmente (*parsing*), ya fue especialmente diseñado para ser sencillo
+sintácticamente (*parsing*), ya fue especialmente diseñado para ser sencillo
y a diferencia de C y C++ su gramática es independiente del contexto
(*context-free grammar*). Esto permite que D pueda ser compilado en pequeños
pasos bien separados:
Inferencia de tipos básica implícita y explícita (mediante ``typeof``):
si no se especifica un tipo al declarar una variable, se infiere del tipo
- de su inicializador.
+ de su valor de inicialización.
Ejemplo::
total += i;
*Templates*:
- clases y funciones pueden ser parametrizadas. Esto permite desarrollar
+ clases y funciones pueden ser generalizadas. Esto permite desarrollar
algoritmos genéricos sin importar el tipo de los datos de entrada, siempre
y cuando todos los tipos tengan una *interfaz* común. Esto también es
conocido como *polimorfismo en tiempo de compilación*, y es la forma más
auto i = sumar!(int)(5, 6); // i == 11
auto f = sumar!(float)(5, 6); // j == 11.0f
- Además se pueden definir bloques de declaraciones parametrizados (esto no
+ Además se pueden definir bloques de declaraciones generalizadas (esto no
es posible en C++), permitiendo instanciar dicho bloque con parámetros
particulares. Esto sirve como un mecanismo para la reutilización de código,
ya que puede incluirse un mismo bloque en distintos lugares (por ejemplo
- clases). Un bloque parametrizado puede verse como una especie de módulo.
+ clases). Un bloque generalizado puede verse como una especie de módulo.
Ejemplo::
bloque!(int, float).x = 5;
float f = bloque!(int, float).foo(7);
- La utilidad más prominente de los bloques parametrizados se da al
+ La utilidad más prominente de los bloques generalizados se da al
acompañarse de *mixins*.
-Instanciación implícita de funciones parametrizadas:
+Instanciación implícita de funciones generalizadas:
el lenguaje es capaz de deducir los parámetros siempre que no hayan
ambigüedades
si una función cumple ciertas reglas básicas (como por ejemplo no tener
efectos colaterales) puede ser ejecutada en tiempo de compilación en vez de
tiempo de ejecución. Esto permite hacer algunos cálculos que no cambian de
- ejecución en ejecución al momento de compilar, mejorando la performance
- o permitiendo formas avanzadas de metaprogramación. Esta característica se
+ ejecución en ejecución al momento de compilar, mejorando el rendimiento
+ o permitiendo formas avanzadas de meta-programación. Esta característica se
vuelve particularmente útil al combinarse con *string mixins*.
Ejemplo::
Rendimiento:
la :ref:`d_generic` permite realizar muchas optimizaciones ya que se
resuelve en tiempo de compilación y por lo tanto aumentando la
- *performance* en la ejecución.
+ rendimiento en la ejecución.
Número de punto flotante de 80 bits:
El tipo ``real`` de D_ tiene precisión de 80 bits si la plataforma lo
Programación de alto nivel
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Programa de alto nivel se refiere a construcciones más avanzadas que un loop.
-Expresiones semánticamente más ricas que permiten mayor expresividad al
-programador o le permiten focalizarse de mejora manera en los algoritmos
-independizándose del *hardware* o de como funciona una computadora. Es
-exactamente el opuesto a :ref:`d_low_level`.
+Programación de alto nivel se refiere a construcciones más avanzadas que una
+sentencia para iterar; expresiones con una semántica más ricas que permiten
+mayor expresividad al programador o le permiten focalizarse de mejora manera
+en los algoritmos independizándose del *hardware* o de como funciona una
+computadora. Es exactamente el opuesto a :ref:`d_low_level`.
En general estas características tiene como efecto secundario una mejora de la
productividad de los programadores. D_ adopta herramientas de muchos lenguajes
Objetos *pesados*:
objetos polimórficos como los de cualquier lenguaje con orientación real
- a objetos. Estos objetos poseen una tabla virtual para *dispatch* dinámico,
+ a objetos. Estos objetos poseen una tabla virtual para despacho dinámico,
todos los métodos son virtuales a menos que se indique lo contrario
y tienen semántica de referencia [#drefsem]_. Estos objetos tienen un
*overhead* comparados a los objetos *livianos* pero aseguran una semántica
D_ implementa las siguientes formas de diseño por contrato (todas se
ejecutan siempre y cuando no se compile en modo *release*, de manera de no
- sacrificar *performance* cuando es necesario):
+ sacrificar rendimiento cuando es necesario):
Pre y post condiciones:
Ejemplo::
Ejemplo::
- double d; // inicializado a NaN
- int x; // inicializado a 0
- Fecha f; // inicializado a null
- byte[5] a; // inicializados todos los valores a 0
+ double d; // inicializado a NaN
+ int x; // inicializado a 0
+ Fecha f; // inicializado a null
+ byte[5] a; // inicializados todos los valores a 0
long l = void; // NO inicializado (explícitamente)
*RAII* (*Resource Adquisition Is Initialization*):
int f(Lock lock) {
lock.lock();
scope (exit)
- lock.unlock(); // ejecutado siempre que salga de f()
+ lock.unlock(); // ejecutado siempre que salga de f()
auto trans = new Transaccion;
scope (success)
- trans.commit(); // ejecutado si sale con "return"
+ trans.commit(); // ejecutado si sale con "return"
scope (failure)
- trans.rollback(); // ejecutado si sale por una excepción
+ trans.rollback(); // ejecutado si sale por una excepción
if (condicion)
- throw Exception("error"); // ejecuta lock.unlock() y trans.rollback()
+ throw Exception("error"); // lock.unlock() y trans.rollback()
else if (otra_condicion)
- return 5; // ejecuta lock.unlock() y trans.commit()
- return 0; // ejecuta lock.unlock() y trans.commit()
+ return 5; // lock.unlock() y trans.commit()
+ return 0; // lock.unlock() y trans.commit()
}
Esta es una nueva forma de poder escribir código *exception-safe*, aunque
de recolección de basura en dicho lenguaje (se explica por qué las
particularidades descriptas en la sección anterior complican la
recolección de basura y cuales son las que más molestan).
- ESTADO: TERMINADO
+ ESTADO: TERMINADO, CORREGIDO
.. _dgc:
El control sobre la alineación de memoria es otra complicación sobre el
recolector de basura, incluso aunque éste sea conservativo. Dado que tratar la
memoria de forma conservativa byte a byte sería impracticable (tanto por la
-cantidad de falsos positivos que esto provocaría como por el impacto en la
-eficiencia por el exceso de posibles punteros a revisar, además de lo
+cantidad de falsos positivos que esto provocaría como por el impacto en el
+rendimiento por el exceso de posibles punteros a revisar, además de lo
ineficiente que es operar sobre memoria no alineada), en general el recolector
asume que el usuario nunca va a tener la única referencia a un objeto en una
estructura no alineada al tamaño de palabra.
D_ soporta el paradigma de orientación a objetos, donde es común permitir que
un objeto, al ser destruido, realice alguna tarea de finalización (a través de
una función miembro llamada *destructor*, o ``~this()`` en D_). Esto significa
-que el recolector, al encontrar que un objeto no es más referenciados, debe
+que el recolector, al encontrar que no hay más referencias a un objeto, debe
ejecutar el destructor.
La especificación dice:
Esta restricción en realidad se ve relaja con el soporte de *RAII*. Si se
utiliza la palabra clave ``scope`` al crear una serie de objetos, estos serán
-destruídos determinísticamente al finalizar el *scope* actual en el orden
+destruidos determinísticamente al finalizar el *scope* actual en el orden
inverso al que fueron creados y, por lo tanto, un usuario podría hacer uso de
los atributos que sean referencias a otros objetos creados con ``scope`` si el
orden en que fueron creados (y por lo tanto en que serán destruidos) se lo
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).
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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
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
*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).
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``:
^^^^^^^^^^^^^^^
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).
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
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
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
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
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
-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``).
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*.
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.
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.
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)
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
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
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::
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::
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_.
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.
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
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
^^^^^^^^^^
-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
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)*:
- 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
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
<gc_free_list>`), es relativamente sofisticada. El esquema de *pools*
y bloques permite disminuir considerablemente los problemas de *fragmentación*
de memoria y evita búsquedas de *huecos* que pueden ser costosas (como
-*best-fit* [#dgcbestfit]_) o desperdiciar mucho especio (como *first-fit*
+*best-fit* [#dgcbestfit]_) o desperdiciar mucho espacio (como *first-fit*
[#dgcfirstfit]_), logrando un buen equilibrio entre velocidad y espacio
desperdiciado.
Conjuntos de bits para indicadores
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-El algoritmo cláscio propone almacenar en la propia celda la marca (para la
+El algoritmo clásico propone almacenar en la propia celda la marca (para la
fase de marcado) y otros indicadores. El algoritmo del recolector actual
utiliza conjuntos de bits. Esto trae dos ventajas principales:
de información.
* Mejora la localidad de referencia, ya que los indicadores se escriben de
- forma muy compacta y en una región de memoria contígua que generalmente
+ forma muy compacta y en una región de memoria contigua que generalmente
puede entrar en el cache o en pocas páginas de memoria acelerando
considerablemente la fase de marcado.
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.
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
``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*
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
-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
-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.
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]_.
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
-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
^^^^^^^^^^
-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]_.
-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.
desperdiciados en bits inutilizados).
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
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]_.
.. Introducción a la importancia de la recolección de basura y sus
principales técnicas, con sus ventajas y desventajas. También se da
un breve recorrido sobre el estado del arte.
- ESTADO: TERMINADO
+ ESTADO: TERMINADO, CORREGIDO
.. _gc:
investigaciones).
En las primeras implementaciones de recolectores de basura la penalización en
-la eficiencia del programa se volvía prohibitiva para muchas aplicaciones. Es
+el rendimiento del programa se volvía prohibitiva para muchas aplicaciones. Es
por esto que hubo bastante resistencia a la utilización de recolectores de
basura, pero el avance en la investigación fue haciendo que cada vez sea una
-alternativa más viable al manejo manual de memoria, incluso para apliaciones
-con altos requerimientos de eficiencia. En la actualidad un programa que
-utiliza un recolector moderno puede ser comparable en eficiencia con uno que
+alternativa más viable al manejo manual de memoria, incluso para aplicaciones
+con altos requerimientos de rendimiento. En la actualidad un programa que
+utiliza un recolector moderno puede ser comparable en rendimiento con uno que
utiliza un esquema manual. En particular, si el programa fue diseñado con el
recolector de basura en mente en ciertas circunstancias puede ser incluso más
eficiente que uno que hace manejo explícito de la memoria. Muchos recolectores
lenguajes de programación que requieran un recolector de basura conservativo.
Por último, siendo que el recolector de basura es parte del programa de forma
-indirecta, es común ver en la literatura que se direfencia entre
-2 partes del programa, el recolector de basura y el programa en sí. Dado que
-para el recolector de basura, lo único que interesa conocer del programa en
-sí son los cambios al grafo de conectividad de las celdas, normalmente se lo
-llama *mutator* (mutador).
+indirecta, es común ver en la literatura que se diferencia entre dos partes
+del programa, el recolector de basura y el programa en sí. Dado que para el
+recolector de basura, lo único que interesa conocer del programa en sí son los
+cambios al grafo de conectividad de las celdas, normalmente se lo llama
+*mutator*.
búsqueda, que puede realizarse *primero a lo ancho* (*breadth-first*)
o *primero a lo alto* (*depth-first*) del grafo, el marcado de un grafo
también puede realizarse de ambas maneras. Cada una podrá o no tener efectos
-en la eficiencia, en particular dependiendo de la aplicación puede convenir
+en el rendimiento, en particular dependiendo de la aplicación puede convenir
uno u otro método para lograr una mejor localidad de referencia.
.. [#gccycle] Un ciclo es un camino donde el *vértice inicial* es el mismo
completamente arbitrarios, ya que cualquier *vértice interior* puede ser un
*vértice terminal*.
-Un algoritmo simple (recursivo) de marcado *primero a lo alto* puede ser el
+Un algoritmo simple (recursivo) de marcado *primero a lo alto* puede ser el
siguiente (asumiendo que partimos con todos los vértices sin marcar)
[#gcpseudo]_::
color, gris generalmente, indica que una celda debe ser visitada. Esto permite
algoritmos :ref:`concurrentes <gc_concurrent>` e :ref:`incrementales
<gc_inc>`, además de otro tipo de optimizaciones. Entonces, lo que plantea
-esta abtracción es una nueva partición del heap al momento de marcar, esta vez
-son 3 porciones: blanca, gris y negra.
+esta abstracción es una nueva partición del heap al momento de marcar, esta
+vez son tres porciones: blanca, gris y negra.
Al principio todas las celdas se pintan de blanco, excepto el *root set* que
se punta de gris. Luego se van obteniendo celdas del conjunto de las grises
Cuando esto sucede, las celdas que participan del ciclo tienen siempre su
contador mayor que 0, sin embargo puede no haber ningún elemento del *root
set* que apunte a una celda dentro del ciclo, por lo tanto el ciclo es
-*basura* (al igual que cualquier otra celda que sea referenciada por el ciclo
-pero que no tenga otras referencias externas) y sin embargo los contadores no
-son 0. Los ciclos, por lo tanto, *rompen* la invariante del conteo de
-referencia.
+*basura* (al igual que cualquier otra celda para la cual hayan referencias
+desde el ciclo pero que no tenga otras referencias externas) y sin embargo los
+contadores no son 0. Los ciclos, por lo tanto, violan la invariante del conteo
+de referencia.
Hay formas de solucionar esto, pero siempre recaen en un esquema que va por
fuera del conteo de referencias puro. En general los métodos para solucionar
-esto son variados y van desde realizar un marcado del subgrafo para detectar
+esto son variados y van desde realizar un marcado del sub-grafo para detectar
nodos hasta tener otro recolector completo de *emergencia*, pasando por tratar
los ciclos como un todo contar las referencias al ciclo completo en vez de
a cada celda en particular.
del algoritmo. Por simplicidad se asumen celdas de tamaño fijo con dos
punteros, ``left`` (``l``) y ``right`` (``r``) y se muestra el contador de
referencias abajo del nombre de cada celda. Se parte con una pequeña
-estructura ya construída y se muestra como opera el algoritmo al eliminar
+estructura ya construida y se muestra como opera el algoritmo al eliminar
o cambiar una referencia (cambios en la conectividad del grafo). En un
comienzo todas las celdas son accesibles desde el *root set* por lo tanto son
todas parte del *live set*.
estuvieran asignando por primera vez. Como la posición en memoria de las
celdas cambia al ser movidas, es necesario actualizar la dirección de memoria
de todas las celdas *vivas*. Para esto se almacena una dirección de memoria de
-redirección, *forwarding address*, en las celdas que mueven. La *forwarding
+re-dirección, *forwarding address*, en las celdas que mueven. La *forwarding
address* sirve a su vez de marca, para no recorrer una celda dos veces (como
se explica en :ref:`gc_intro_mark`). Cuando se encuentra una celda que ya fue
movida, simplemente se actualiza la referencia por la cual se llegó a esa
<gc_concurrent>`. Las diferencias con los esquemas vistos hasta ahora son
evidentes. La principal ventaja sobre el marcado y barrido (que requiere una
pasada sobre el *live set*, el marcado, y otra sobre el *heap* entero, el
-barrido) es que este método require una sola pasada y sobre las celdas vivas
+barrido) es que este método requiere una sola pasada y sobre las celdas vivas
del *heap* solamente. La principal desventaja es copia memoria, lo que puede
ser particularmente costoso, además de requerir, como mínimo, el doble de
memoria de lo que el *mutator* realmente necesita. Esto puede traer en
cuando el *mutator* cambia una referencia, se marca *gris* la celda que la
contiene, de modo que el recolector vuelva a visitarla.
-En general la eficiencia de los recolectores incrementales disminuye
+En general el rendimiento de los recolectores incrementales disminuye
considerablemente cuando el *mutator* actualiza muy seguido el grafo de
conectividad, porque debe re-escanear sub-grafos que ya había escaneado una
y otra vez. A esto se debe también que en general el tiempo de procesamiento
esquema simple pero con limitaciones, entre las principales, el costo de
asignar puede ser alto si hay muchos tamaños distintos de celda y soportar
tamaño de celda variable puede ser complejo o acarrear muchas otras
-ineficiencias. :ref:`gc_mark_sweep` en general usa este esquema, al igual que
-:ref:`gc_rc`.
+ineficiencias. El :ref:`marcado y barrido <gc_mark_sweep>` en general usa este
+esquema, al igual que el :ref:`conteo de referencias <gc_rc>`.
Otro forma de organizar el *heap* es utilizándolo como una especie de *stack*
en el cual para asignar simplemente se incrementa un puntero. Este esquema es
simple y eficiente, si el recolector puede mover celdas (ver
:ref:`gc_moving`); de otra manera asignar puede ser muy costoso si hay que
buscar un *hueco* en el heap (es decir, deja de reducirse a incrementar un
-puntero). El clásico ejemplo de esta familia es :ref:`gc_copy`.
+puntero). El clásico ejemplo de esta familia es el algoritmo visto en
+:ref:`gc_copy`.
Sin embargo, entre estos dos extremos, hay todo tipo de híbridos. Existen
recolectores basados en *regiones*, que se encuentran en un punto intermedio.
alto nivel) en general disponen de recolectores precisos.
Hay casos donde se posee información de tipos para algunas celdas solamente,
-o más comunmente se posee información de tipos de celdas que se encuentran en
+o más comúnmente se posee información de tipos de celdas que se encuentran en
el *heap* pero no para el *stack* y registros (por ejemplo [MOLA06]_). En
estos casos se puede adoptar un esquema híbrido y tratar algunas referencias
de forma conservativa y otras de forma precisa, de manera de mitigar, aunque
`Boehm-Demers-Wiser`_ ([BOEH88]_, [BOEH91]_, [BOEH93]_, [BOEHWD]_) aunque
puede comportarse de forma semi-precisa si el usuario se encarga de darle la
información de tipos (en cuyo caso el recolector deja de ser transparente para
-el usuario). Otros ejemplos de recolectores con cierto grado de
-conservativismo son el :ref:`recolector actual de D <dgc_actual>` y [BLAC08]_.
+el usuario). Otros ejemplos de recolectores con cierto grado de precisión son
+el :ref:`recolector actual de D <dgc_actual>` y [BLAC08]_.
.. _gc_part:
-Recolección particionada / generacional
+Recolección por particiones / generacional
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Otra forma de reducir la cantidad de pausas y la cantidad de trabajo realizado
-por el recolector en general es particionando el *heap* de manera tal de
-recolectar solo las partes donde más probabilidad de encontrar *basura* haya.
+por el recolector en general es dividiendo el *heap* en particiones de manera
+tal de recolectar solo las partes donde más probabilidad de encontrar *basura*
+haya.
Entonces, si el recolector tiene algún mecanismo para identificar zonas de
alta concentración de *basura* puede hacer la recolección solo en ese área
Sin embargo encontrar zonas de alta concentración no es trivial. La forma más
-divulgada de encontrar estas zonas es particionando el *heap* en un área
+divulgada de encontrar estas zonas es dividiendo el *heap* en una partición
utilizada para almacenar celdas *jóvenes* y otra para celdas *viejas*. Una
-celda *vieja* es aquella que ha *sobrevivido* una cantidad N de recolecciones,
-mientras que el resto se consideran *jóvenes* (las celdas *nacen* jóvenes).
-Los recolectores que utilizan este tipo de partición son ampliamente conocido
-como recolectores **generacionales**. La *hipótesis generacional* dice que el
-área de celdas jóvenes tiene una mayor probabilidad de ser un área de alta
-concentración de basura [JOLI96]_. Basandose en esto, los recolectores
-generacionales primero intentan recuperar espacio del área de celdas jóvenes
-y luego, de ser necesario, del área de celdas viejas. Es posible tener varias
-generaciones e ir subiendo de generación a generación a medida que es
-necesario. Sin embargo en general no se obtienen buenos resultados una vez que
-se superan las 3 particiones. La complejidad que trae este método es que para
-recolectar la generación joven es necesario tomar las referencias de la
-generación vieja a la joven como parte del *root set* (de otra forma podrían
-tomarse celdas como *basura* que todavía son utilizadas por las celdas
-viejas). Revisar toda la generación vieja no es una opción porque sería
-prácticamente lo mismo que realizar una recolección del *heap* completo. La
-solución está entonces, una vez más, en instrumentar el *mutator* para que
+celda *vieja* es aquella que ha *sobrevivido* una cantidad *N* de
+recolecciones, mientras que el resto se consideran *jóvenes* (las celdas
+*nacen* jóvenes). Los recolectores que utilizan este tipo de partición son
+ampliamente conocido como recolectores **generacionales**. La *hipótesis
+generacional* dice que el área de celdas jóvenes tiene una mayor probabilidad
+de ser un área de alta concentración de basura [JOLI96]_. Basándose en esto,
+los recolectores generacionales primero intentan recuperar espacio del área de
+celdas jóvenes y luego, de ser necesario, del área de celdas viejas. Es
+posible tener varias generaciones e ir subiendo de generación a generación
+a medida que es necesario. Sin embargo en general no se obtienen buenos
+resultados una vez que se superan las 3 particiones. La complejidad que trae
+este método es que para recolectar la generación joven es necesario tomar las
+referencias de la generación vieja a la joven como parte del *root set* (de
+otra forma podrían tomarse celdas como *basura* que todavía son utilizadas por
+las celdas viejas). Revisar toda la generación vieja no es una opción porque
+sería prácticamente lo mismo que realizar una recolección del *heap* completo.
+La solución está entonces, una vez más, en instrumentar el *mutator* para que
avise al recolector cuando cambia una referencia de la generación vieja a la
-joven (no es necesario monitorear las referencias en sentido inverso ya que
+joven (no es necesario vigilar las referencias en sentido inverso ya que
cuando se recolecta la generación vieja se hace una recolección del *heap*
completo).
-Sin embargo, a pesar de ser este el esquema más difundido para particionar el
+Sin embargo, a pesar de ser este el esquema más difundido para dividir el
*heap* y realizar una recolección parcial sobre un área de alta concentración
de basura no es la única. Otros recolectores proponen hacer un análisis
estático del código revisando la conectividad entre los objetos según sus
-tipos (esto es posible solo en lenguajes con tipado estático), de manera tal
+tipos (esto es posible solo en lenguajes con *tipado* estático), de manera tal
de separar en distintas áreas grupos de tipos que no pueden tener referencias
-entre sí [HIRZ03]_. Este análisis hace que sea inecesario instrumentar el
+entre sí [HIRZ03]_. Este análisis hace que sea innecesario instrumentar el
*mutator* para reportar al recolector cambios de referencias
inter-particiones, sencillamente porque queda demostrado que no existe dicho
-tipo de referencias. Esto quita una de las principale ineficiencias
+tipo de referencias. Esto quita una de las principales ineficiencias
y complejidades del esquema generacional.
.. Introducción al trabajo, objetivos, alcance, limitaciones y organización
del documento.
- ESTADO: TERMINADO
+ ESTADO: TERMINADO, CORREGIDO
.. _intro:
tomando particular importancia.
Nuevos algoritmos fueron desarrollados para atacar distintos problemas
-particulares y para mejorar la *performance*, que ha sido una inquietud
+particulares y para mejorar el rendimiento, que ha sido una inquietud
incesante en la investigación de recolectores de basura. Sin embargo el
lenguaje más masivo que ha adoptado un recolector de basura (al menos en el
ámbito empresarial) fue Java_, con el cual la investigación sobre recolección
Organización
----------------------------------------------------------------------------
-Este trabajo se encuentra dividido en 7 cápitos que se describen
+Este trabajo se encuentra dividido en 7 capítulos que se describen
a continuación:
1. :ref:`intro`: breve descripción del problema a tratar, presentando
.. Resumen del trabajo
- ESTADO: TERMINADO
+ ESTADO: TERMINADO, CORREGIDO
.. _resumen:
programación desde que empezaron a forjarse los primero lenguajes con un
mínimo nivel de abstracción, dado que la administración de memoria explícita
ha sido un flagelo constante en el mundo de la informática, provocando
-pérdidas de memoria que degradan la eficiencia de programas de larga vida
+pérdidas de memoria que degradan el rendimiento de programas de larga vida
y siendo la principal fuente de problemas de seguridad, entre otros problemas.
Es por esto que se desde la primera aparición de lenguajes de más alto nivel,
projects / z.facultad / 75.00 / informe.git / commitdiff