para indicar la continuación de un objeto grande (que ocupan más de una
página).
-.. fig:: fig:dgc-org
+.. flt:: fig:dgc-org
- Organización del *heap* del recolector de basura actual de D.
+ Organización del *heap* del recolector de basura actual de D
Organización del *heap*. En este ejemplo todos los *pools* tienen 2 páginas
excepto el *pool* 2 que tiene una sola. El tamaño de bloque que almacena
:vref:`fig:dgc-free-list`). Esto permite asignar objetos relativamente
pequeños de forma bastante eficiente.
-.. fig:: fig:dgc-free-list
+.. flt:: fig:dgc-free-list
- Ejemplo de listas de libres.
+ Ejemplo de listas de libres
.. digraph:: dgc_free_list
Cada *pool* tiene la siguiente información asociada:
*number_of_pages*
- cantidad de páginas que tiene. Esta cantidad es fija en toda la vida de un
+ Cantidad de páginas que tiene. Esta cantidad es fija en toda la vida de un
*pool*.
*pages*
- bloque de memoria contiguo 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).
significado especial:
``FREE``
- indica que la página está completamente libre y que la página está
+ Indica que la página está completamente libre y que la página está
disponible para albergar cualquier tamaño de bloque que sea necesario (pero
una vez que se le asignó un nuevo tamaño de bloque ya no puede ser cambiado
hasta que la página vuelva a liberarse por completo).
``CONTINUATION``
- indica que esta página es la continuación de un objeto grande (es decir,
+ Indica que esta página es la continuación de un objeto grande (es decir,
que ocupa una o más páginas). Luego se presentan más detalles sobre objetos
grandes.
Cada bloque tiene asociados varios atributos:
*mark*
- utilizado en la fase de :ref:`marcado <dgc_algo_mark>`, indica que un nodo
+ Utilizado en la fase de :ref:`marcado <dgc_algo_mark>`, indica que un nodo
ya fue visitado (serían las celdas *negras* en la :ref:`abstracción
tricolor <gc_intro_tricolor>`).
*scan*
- utilizado también en la fase de :ref:`marcado <dgc_algo_mark>`, indica que
+ Utilizado también en la fase de :ref:`marcado <dgc_algo_mark>`, indica que
una celda visitada todavía tiene *hijas* sin marcar (serían las celdas
*grises* en la :ref:`abstracción tricolor <gc_intro_tricolor>`).
*free*
- indica que el bloque está libre (no está siendo utilizado por ningún objeto
+ Indica que el bloque está libre (no está siendo utilizado por ningún objeto
*vivo*). Esto es necesario solo por la forma en la que realiza el
:ref:`marcado <dgc_algo_mark>` y :ref:`barrido <dgc_algo_sweep>` en el
:ref:`algoritmo actual <dgc_algo>` (las celdas con el atributo este
atributo son tomadas como *basura* aunque estén marcadas con *mark*).
*final*
- indica que el bloque contiene un objeto que tiene un destructor (que debe
+ Indica que el bloque contiene un objeto que tiene un destructor (que debe
ser llamado cuando la celda pasa de *viva* a *basura*).
*noscan*
- indica que el bloque contiene un objeto que no tiene punteros y por lo
+ 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*).
completamente libres::
function minimize() is
- for pool in heap
+ foreach pool in heap
all_free = true
- for page in pool
+ foreach page in pool
if page.block_size is not FREE
all_free = false
break
Raíces definidas por el usuario
*roots* (*nroots*, *rootdim*)
- arreglo variable de punteros simples que son tomados como raíces
+ Arreglo variable de punteros simples que son tomados como raíces
provistas por el usuario.
*ranges* (*nranges*, *rangedim*)
- arreglo variable de rangos de memoria que deben ser revisados (de forma
+ Arreglo variable de rangos de memoria que deben ser revisados (de forma
conservativa) como raíces provistas por el usuario. Un rango es una
estructura con dos punteros: ``pbot`` y ``ptop``. Toda la memoria entre
estos dos punteros se toma, palabra por palabra, como una raíz del
Estado interno del recolector
*anychanges*
- variable que indica si en la fase de marcado se encontraron nuevas
+ Variable que indica si en la fase de marcado se encontraron nuevas
celdas con punteros que deban ser visitados. Otra forma de verlo es como
un indicador de si el conjunto de celdas *grises* está vacío luego de
una iteración de marcado (utilizando la :ref:`abstracción tricolor
presentada en :ref:`dgc_algo_mark`.
*inited*
- indica si el recolector fue inicializado.
+ Indica si el recolector fue inicializado.
*stackBottom*
- puntero a la base del *stack* (asumiendo que el stack crece hacia arriba).
+ Puntero a la base del *stack* (asumiendo que el stack crece hacia arriba).
Se utiliza para saber por donde comenzar a visitar el *stack* de forma
conservativa, tomándolo con una raíz del recolector.
*Pools* (*pooltable*, *npools*)
- arreglo variable de punteros a estructuras ``Pool`` (ver más adelante).
+ Arreglo variable de punteros a estructuras ``Pool`` (ver más adelante).
Este arreglo se mantiene siempre ordenado de menor a mayor según la
dirección de memoria de la primera página que almacena.
*bucket*
- listas de libres. Es un arreglo de estructuras ``List`` utilizadas para
+ Listas de libres. Es un arreglo de estructuras ``List`` utilizadas para
guardar la listas de libres de todos los tamaños de bloques posibles (ver
más adelante).
Atributos que cambian el comportamiento
*noStack*
- indica que no debe tomarse al *stack* como raíz del recolector. Esto es
+ Indica que no debe tomarse al *stack* como raíz del recolector. Esto es
muy poco seguro y no debería ser utilizado nunca, salvo casos
extremadamente excepcionales.
*log*
- indica si se debe guardar un registro de la actividad del recolector. Es
+ Indica si se debe guardar un registro de la actividad del recolector. Es
utilizado principalmente para depuración.
*disabled*
- indica que no se deben realizar recolecciones implícitamente. Si al
+ Indica que no se deben realizar recolecciones implícitamente. Si al
tratar de asignar memoria no se puede hallar celdas libres en el *heap*
del recolector, se pide más memoria al sistema operativo sin correr una
recolección para intentar recuperar espacio. Esto es particularmente
Optimizaciones
*p_cache*, *size_cache*
- obtener el tamaño de un bloque dado un puntero es una tarea costosa
+ Obtener el tamaño de un bloque dado un puntero es una tarea costosa
y común. Para evitarla en casos donde se calcula de forma sucesiva el
tamaño del mismo bloque (como puede ocurrir al concatenar arreglos
dinámicos) se guarda el último calculado en estas variables a modo de
*caché*.
*minAddr*, *maxAddr*
- punteros al principio y fin del *heap*. Pueden haber *huecos* entre
+ Punteros al principio y fin del *heap*. Pueden haber *huecos* entre
estos dos punteros que no pertenezcan al *heap* pero siempre se cumple
que si un puntero apunta al *heap* debe estar en este rango. Esto es
útil para hacer un cálculo rápido para descartar punteros que fueron
La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura
:vref:`fig:dgc-pool`):
+.. flt:: fig:dgc-pool
+
+ Vista gráfica de la estructura de un *pool* de memoria
+
+ .. aafig::
+ :scale: 120
+
+ /--- "baseAddr" "ncommitted = i" "topAddr" ---\
+ | V |
+ |/ |/ |/
+ +---- "committed" -----+------- "no committed" ----------+
+ /| /| /|
+ V V V
+ +--------+--------+-----+--------+-----+-------------------+
+ páginas | 0 | 0 | ... | i | ... | "npages - 1" |
+ +--------+--------+-----+--------+-----+-------------------+
+ A A A A A A
+ | | | | | |
+ +--------+--------+-----+--------+-----+-------------------+
+ pagetable | Bins 0 | Bins 1 | ... | Bins i | ... | "Bins (npages-1)" |
+ +--------+--------+-----+--------+-----+-------------------+
+
*baseAddr* y *topAddr*
- punteros al comienzo y fin de la memoria que almacena todas las páginas del
+ Punteros al comienzo y fin de la memoria que almacena todas las páginas del
*pool* (*baseAddr* es análogo al atributo *pages* utilizado en las
secciones anteriores para mayor claridad).
*mark*, *scan*, *freebits*, *finals*, *noscan*
- conjunto de bits (*bitsets*) para almacenar los indicadores descriptos en
+ Conjunto de bits (*bitsets*) para almacenar los indicadores descriptos en
:ref:`dgc_org` para todos los bloques de todas las páginas del *pool*.
*freebits* es análogo a *free* y *finals* a *final* en los atributos
descriptos en las secciones anteriores.
*npages*
- cantidad de páginas que contiene este *pool* (fue nombrado
+ Cantidad de páginas que contiene este *pool* (fue nombrado
*number_of_pages* en las secciones anteriores para mayor claridad).
*ncommitted*
- cantidad de páginas *encomendadas* al sistema operativo (*committed* en
+ Cantidad de páginas *encomendadas* al sistema operativo (*committed* en
inglés). Este atributo no se mencionó anteriormente porque el manejo de
páginas encomendadas le agrega una complejidad bastante notable al
recolector y es solo una optimización para un sistema operativo en
particular (Microsoft Windows).
*pagetable*
- arreglo de indicadores de tamaño de bloque de cada página de este *pool*.
+ Arreglo de indicadores de tamaño de bloque de cada página de este *pool*.
Los indicadores válidos son ``B_16`` a ``B_2048`` (pasando por los valores
posibles de bloque mencionados anteriormente, todos con el prefijo
"``B_``"), ``B_PAGE``, ``B_PAGEPLUS`` (análogo a ``CONTINUATION``),
``B_UNCOMMITTED`` (valor que tienen las páginas que no fueron encomendadas
aún) y ``B_FREE``.
-.. fig:: fig:dgc-pool
-
- Vista gráfica de la estructura de un *pool* de memoria.
-
- .. aafig::
- :scale: 120
-
- /--- "baseAddr" "ncommitted = i" "topAddr" ---\
- | V |
- |/ |/ |/
- +---- "committed" -----+------- "no committed" ----------+
- /| /| /|
- V V V
- +--------+--------+-----+--------+-----+-------------------+
- páginas | 0 | 0 | ... | i | ... | "npages - 1" |
- +--------+--------+-----+--------+-----+-------------------+
- A A A A A A
- | | | | | |
- +--------+--------+-----+--------+-----+-------------------+
- pagetable | Bins 0 | Bins 1 | ... | Bins i | ... | "Bins (npages-1)" |
- +--------+--------+-----+--------+-----+-------------------+
-
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
Inicialización y terminación
*initialize()*
- inicializa las estructuras internas del recolector para que pueda ser
+ Inicializa las estructuras internas del recolector para que pueda ser
utilizado. Esta función la llama la biblioteca *runtime* antes de que el
programa comience a correr.
*Dtor()*
- libera todas las estructuras que utiliza el recolector.
+ Libera todas las estructuras que utiliza el recolector.
Manipulación de raíces definidas por el usuario
*addRoot(p)*, *removeRoot(p)*, *rootIter(dg)*
- agrega, remueve e itera sobre las raíces simples definidas por el
+ Agrega, remueve e itera sobre las raíces simples definidas por el
usuario.
*addRange(pbot, ptop)*, *remove range(pbot)*, *rangeIter(dg)*
- agrega, remueve e itera sobre los rangos de raíces definidas por el
+ Agrega, remueve e itera sobre los rangos de raíces definidas por el
usuario.
Manipulación de indicadores
*getBits(pool, biti)*
- obtiene los indicadores especificados para el bloque de índice ``biti``
+ Obtiene los indicadores especificados para el bloque de índice ``biti``
en el *pool* ``pool``.
*setBits(pool, biti, mask)*
- establece los indicadores especificados en ``mask`` para el bloque de
+ Establece los indicadores especificados en ``mask`` para el bloque de
índice ``biti`` en el *pool* ``pool``.
*clrBits(pool, biti, mask)*
- limpia los indicadores especificados en ``mask`` para el bloque de
+ Limpia los indicadores especificados en ``mask`` para el bloque de
índice ``biti`` en el *pool* ``pool``.
Cada bloque (*bin* en la terminología de la implementación del recolector)
compuesta por la conjunción de los siguientes valores:
*FINALIZE*
- el objeto almacenado en el bloque tiene un destructor (indicador
+ El objeto almacenado en el bloque tiene un destructor (indicador
*finals*).
*NO_SCAN*
- el objeto almacenado en el bloque no contiene punteros (indicador
+ El objeto almacenado en el bloque no contiene punteros (indicador
*noscan*).
*NO_MOVE*
- el objeto almacenado en el bloque no debe ser movido [#dgcmove]_.
+ El objeto almacenado en el bloque no debe ser movido [#dgcmove]_.
.. [#dgcmove] Si bien el recolector actual no tiene la capacidad de mover
objetos, la interfaz del recolector hacer que sea posible una
Búsquedas
*findPool(p)*
- busca el *pool* al que pertenece el objeto apuntado por ``p``.
+ Busca el *pool* al que pertenece el objeto apuntado por ``p``.
*findBase(p)*
- busca la dirección base (el inicio) del bloque apuntado por ``p``
+ Busca la dirección base (el inicio) del bloque apuntado por ``p``
(``find_block()`` según la sección :ref:`dgc_algo_mark`).
*findSize(p)*
- busca el tamaño del bloque apuntado por ``p``.
+ Busca el tamaño del bloque apuntado por ``p``.
*getInfo(p)*
- obtiene información sobre el bloque apuntado por ``p``. Dicha
+ Obtiene información sobre el bloque apuntado por ``p``. Dicha
información se retorna en una estructura ``BlkInfo`` que contiene los
siguientes atributos: ``base`` (dirección del inicio del bloque),
``size`` (tamaño del bloque) y ``attr`` (atributos o indicadores del
bloque, los que se pueden obtener con ``getBits()``).
*findBin(size)*
- calcula el tamaño de bloque más pequeño que pueda contener un objeto de
+ Calcula el tamaño de bloque más pequeño que pueda contener un objeto de
tamaño ``size`` (``find_block_size()`` según lo visto en
:ref:`dgc_algo_alloc`).
Asignación de memoria
*reserve(size)*
- reserva un nuevo *pool* de al menos ``size`` bytes. El algoritmo nunca
+ Reserva un nuevo *pool* de al menos ``size`` bytes. El algoritmo nunca
crea un *pool* con menos de 256 páginas (es decir, 1 MiB).
*minimize()*
- minimiza el uso de la memoria retornando *pools* sin páginas usadas al
+ Minimiza el uso de la memoria retornando *pools* sin páginas usadas al
sistema operativo.
*newPool(n)*
- reserva un nuevo *pool* con al menos ``n`` páginas. Junto con
+ Reserva un nuevo *pool* con al menos ``n`` páginas. Junto con
``Pool.initialize()`` es análoga a ``new_pool()``, solo que esta función
siempre incrementa el número de páginas a, al menos, 256 páginas (es
decir, los *pools* son siempre mayores a 1 MiB). Si la cantidad de
*pools* de 8 MiB o la cantidad pedida, si ésta es mayor.
*Pool.initialize(n_pages)*
- inicializa un nuevo *pool* de memoria. Junto con ``newPool()`` es
+ Inicializa un nuevo *pool* de memoria. Junto con ``newPool()`` es
análoga a ``new_pool()``. Mientras ``newPool()`` es la encargada de
calcular la cantidad de páginas y crear el objeto *pool*, esta función
es la que pide la memoria al sistema operativo. Además inicializa los
``finals`` de todo el *pool*.
*allocPage(bin)*
- asigna a una página libre el tamaño de bloque ``bin`` y enlaza los
+ Asigna a una página libre el tamaño de bloque ``bin`` y enlaza los
nuevos bloques libres a la lista de libres correspondiente (análogo
a ``assign_page()``).
a ``find_pages(n)``).
*malloc(size, bits)*
- asigna memoria para un objeto de tamaño ``size`` bytes. Análoga al
+ Asigna memoria para un objeto de tamaño ``size`` bytes. Análoga al
algoritmo ``new(size, attr)`` presentado, excepto que introduce además
un caché para no recalcular el tamaño de bloque necesario si se realizan
múltiples asignaciones consecutivas de objetos del mismo tamaño y que la
asignación de objetos pequeños no está separada en una función aparte.
*bigAlloc(size)*
- asigna un objeto grande (análogo a ``new_big()``). La implementación es
+ Asigna un objeto grande (análogo a ``new_big()``). La implementación es
mucho más compleja que la presentada en ``new_big()``, pero la semántica
es la misma. La única diferencia es que esta función aprovecha que
``fullcollectshell()`` / ``fullcollect()`` retornan la cantidad de
objeto grande y pasar directamente a crear un nuevo *pool*.
*free(p)*
- libera la memoria apuntada por ``p`` (análoga a ``delete()`` de la
+ Libera la memoria apuntada por ``p`` (análoga a ``delete()`` de la
sección anterior).
Recordar que la ``pooltable`` siempre se mantiene ordenada según la
Recolección
*mark(pbot, ptop)*
- marca un rango de memoria. Este método es análogo al ``mark_range()``
+ Marca un rango de memoria. Este método es análogo al ``mark_range()``
presentado en la sección :ref:`dgc_algo_mark`.
*fullcollectshell()*
- guarda los registros en el *stack* y llama a ``fullcollect()``. El
+ 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
caso).
*fullcollect(stackTop)*
- realiza la recolección de basura. Es análoga a ``collect()`` pero es
+ 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
bits estén intactas. Esto permite detectar de forma temprana errores tanto
en el recolector como en el programa del usuario.
- .. fig:: fig:sentinel
+ .. flt:: fig:sentinel
- Esquema de un bloque cuando está activada la opción ``SENTINEL``.
+ Esquema de un bloque cuando está activada la opción ``SENTINEL``
.. aafig::
:textual:
o mejorarlo. Esto a su vez provoca que, al no disponer de una implementación
de referencia sencilla, sea muy difícil implementar un recolector nuevo.
+.. highlight:: d
+
Este es, probablemente, la raíz de todos los demás problemas del recolector
actual. Para ilustrar la dimensión del problema se presenta la implementación
real de la función ``bigAlloc()``::
De todas maneras queda mucho lugar para mejoras, y es un tema recurrente en el
grupo de noticias de D_ y se han discutido formas de poder hacer que, al menos
el *heap* sea preciso [NGD44607]_ [NGD29291]_. Además se mostró un interés
-general por tener un recolector más preciso [NGDN87831]_, pero no han habido
+general por tener un recolector más preciso [NGD87831]_, pero no han habido
avances al respecto.
Otra forma de minimizar los efectos de la falta de precisión que se ha
Se ha sugerido en el pasado el uso de *pools* y listas de libres específicos
de hilos, de manera de disminuir la contención, al menos para la asignación de
-memoria [NGD75952]_ [NGDN87831]_.
+memoria [NGD75952]_ [NGD87831]_.
Además se ha mostrado un interés por tener un nivel de concurrencia aún mayor
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, históricamente una de las principales críticas
-al lenguaje [NGDN87831]_ [NGL3937]_ [NGD22968]_ [NGA15246]_ [NGD5622]_
+al lenguaje [NGD87831]_ [NGL3937]_ [NGD22968]_ [NGA15246]_ [NGD5622]_
[NGD2547]_ [NGD18354]_.
mejorarse:
Listas de libres
- hay 12 listas de libres, como para guardar bloques de tamaño de ``B_16``
+ 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
+ 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
actualmente). Esto es propenso a errores y difícil de mantener.
Uso de señales
- el recolector actual utiliza las señales del sistema operativo ``SIGUSR1``
+ El recolector actual utiliza las señales del sistema operativo ``SIGUSR1``
y ``SIGUSR2`` para pausar y reanudar los hilos respectivamente. Esto
puede traer inconvenientes a usuarios que desean utilizar estas
señales en sus programas (o peor aún, si interactúan con bibliotecas
de C que hacen uso de estas señales) [NGD5821]_.
Marcado iterativo
- si bien esto se mencionó como algo bueno del recolector actual, es un
+ 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*.
En general en la comunidad de D_ no hay mayores críticas al marcado y barrido
en sí, si no más bien a problemas asociados a la implementación actual,
principalmente a las grandes pausas o la falta de :ref:`precisión
-<gc_conserv>` [NGD54084]_ [NGL13744]_ [NGD44607]_ [NGD29291]_ [NGDN87831]_
-[NGDN87831]_ [NGL3937]_ [NGD22968]_ [NGA15246]_ [NGD5622]_ [NGD2547]_
+<gc_conserv>` [NGD54084]_ [NGL13744]_ [NGD44607]_ [NGD29291]_ [NGD87831]_
+[NGD87831]_ [NGL3937]_ [NGD22968]_ [NGA15246]_ [NGD5622]_ [NGD2547]_
[NGD18354]_.
Esta familia de algoritmos se adapta bien a los requerimientos principales de
projects / z.facultad / 75.00 / informe.git / blobdiff