X-Git-Url: https://git.llucax.com/z.facultad/75.00/informe.git/blobdiff_plain/9807a6191b2fbf16cd9c05766a410b9844a372f3..a112b981181e8bd7bafc51d657dbf862e90612fd:/source/dgc.rst diff --git a/source/dgc.rst b/source/dgc.rst index b5460a8..804d554 100644 --- a/source/dgc.rst +++ b/source/dgc.rst @@ -49,7 +49,7 @@ 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 +Al proveer acceso a *assembly*, 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*. @@ -337,11 +337,11 @@ Atributos de *pool* ^^^^^^^^^^^^^^^^^^^ Cada *pool* tiene la siguiente información asociada: -*number_of_pages*: +*number_of_pages* cantidad de páginas que tiene. Esta cantidad es fija en toda la vida de un *pool*. -*pages*: +*pages* bloque de memoria contiguo de tamaño ``PAGE_SIZE * number_of_pages`` (siendo ``PAGE_SIZE`` el tamaño de página, que normalmente son 4096 bytes). @@ -356,13 +356,13 @@ Una página siempre almacena bloques del mismo tamaño, que pueden ser 16, 32, ``PAGE``). Además hay dos tamaños de bloque simbólicos que tienen un significado especial: -``FREE``: +``FREE`` indica que la página está completamente libre y que la página está disponible para albergar cualquier tamaño de bloque que sea necesario (pero una vez que se le asignó un nuevo tamaño de bloque ya no puede ser cambiado hasta que la página vuelva a liberarse por completo). -``CONTINUATION``: +``CONTINUATION`` indica que esta página es la continuación de un objeto grande (es decir, que ocupa una o más páginas). Luego se presentan más detalles sobre objetos grandes. @@ -375,28 +375,28 @@ Atributos de bloque ^^^^^^^^^^^^^^^^^^^ Cada bloque tiene asociados varios atributos: -*mark*: +*mark* utilizado en la fase de :ref:`marcado `, indica que un nodo ya fue visitado (serían las celdas *negras* en la :ref:`abstracción tricolor `). -*scan*: +*scan* utilizado también en la fase de :ref:`marcado `, indica que una celda visitada todavía tiene *hijas* sin marcar (serían las celdas *grises* en la :ref:`abstracción tricolor `). -*free*: +*free* indica que el bloque está libre (no está siendo utilizado por ningún objeto *vivo*). Esto es necesario solo por la forma en la que realiza el :ref:`marcado ` y :ref:`barrido ` en el :ref:`algoritmo actual ` (las celdas con el atributo este atributo son tomadas como *basura* aunque estén marcadas con *mark*). -*final*: +*final* indica que el bloque contiene un objeto que tiene un destructor (que debe ser llamado cuando la celda pasa de *viva* a *basura*). -*noscan*: +*noscan* indica que el bloque contiene un objeto que no tiene punteros y por lo tanto no debe ser marcado de forma conservativa (no tiene *hijas*). @@ -455,31 +455,42 @@ Esta fase consiste de varios pasos, que pueden resumirse en el siguiente algoritmo:: function mark_phase() is - more_to_scan = false + global more_to_scan = false stop_the_world() clear_mark_scan_bits() mark_free_lists() mark_static_data() push_registers_into_stack() + thread_self.stack.end = get_stack_top() mark_stacks() + pop_registers_from_stack() mark_user_roots() mark_heap() start_the_world() La variable **global** ``more_to_scan`` indica al algoritmo iterativo cuando -debe finalizar: la función ``mark()`` (que veremos más adelante) lo pone en -``true`` cuando una nueva celda debe ser visitada, por lo tanto la iteración -se interrumpe cuando no hay más celdas por visitar. +debe finalizar: la función ``mark_range()`` (que veremos más adelante) lo pone +en ``true`` cuando una nueva celda debe ser visitada, por lo tanto la +iteración se interrumpe cuando no hay más celdas por visitar. -Las funciones ``stop_the_world()`` y ``start_the_world()`` sencillamente -pausan y reanudan todos los hilos respectivamente:: +Las funciones ``stop_the_world()`` y ``start_the_world()`` pausan y reanudan +todos los hilos respectivamente (salvo el actual). Al pausar los hilos además +se guardan los registros del procesador en el *stack* y se guarda la posición +actual del *stack* para que la fase de marcado pueda recorrerlos:: function stop_the_world() is foreach thread in threads + if thread is thread_self + continue thread.pause() + push_registers_into_stack() + thread.stack.end = get_stack_top() function start_the_world() is foreach thread in threads + if thread is thread_self + continue + pop_registers_from_stack() thread.resume() La función ``clear_mark_scan_bits()`` se encarga de restablecer todos los @@ -517,9 +528,7 @@ Primero se marca el área de memoria estática de manera :ref:`conservativa ` (es decir, tomando cada *word* como si fuera un puntero):: function mark_static_data() is - foreach word in static_data - pointer = cast(void*) word - mark(pointer) + mark_range(static_data.begin, static_data.end) Para poder tomar los registros como parte del *root set* primero se apilan en el *stack* a través de la función:: @@ -528,14 +537,19 @@ en el *stack* a través de la función:: foreach register in registers push(register) +Y luego se descartan (no es necesario ni correcto restablecer los valores ya +que podrían tener nuevos valores) al sacarlos de la pila:: + + function pop_registers_from_stack() is + foreach register in reverse(registers) + pop() + Una vez hecho esto, basta marcar (de forma conservativa) los *stacks* de todos los threads para terminar de marcar el *root set*:: function mark_stacks() is foreach thread in threads - foreach word in thread.stack - pointer = cast(void*) word - mark(pointer) + mark_range(thread.stack.begin, thread.stack.end) Dado que D_ soporta manejo de memoria manual al mismo tiempo que memoria automática, es posible que existan celdas de memoria que no estén en el *root @@ -546,20 +560,23 @@ estas nuevas raíces. Es por esto que para concluir el marcado del *root set* completo se procede a marcar las raíces definidas por el usuario:: function mark_user_roots() is - foreach pointer in user_roots - mark(pointer) + foreach root_range in user_roots + mark_range(root_range.begin, root_range.end) El algoritmo de marcado no es recursivo sino iterativo por lo tanto al marcar una celda (o bloque) no se siguen sus *hijas*, solo se activa el bit de *scan* (a menos que la celda no contenga punteros, es decir, tenga el bit *noscan*):: - function mark(pointer) is - [pool, page, block] = find_block(pointer) - if block is not null and block.mark is false - block.mark = true - if block.noscan is false - block.scan = true - more_to_scan = true + function mark_range(begin, end) is + pointer = begin + while pointer < end + [pool, page, block] = find_block(pointer) + if block is not null and block.mark is false + block.mark = true + if block.noscan is false + block.scan = true + global more_to_scan = true + pointer++ Por lo tanto en este punto, tenemos todas las celdas inmediatamente alcanzables desde el *root set* marcadas y con el bit *scan* activado si la @@ -568,8 +585,8 @@ forma conservativa) iterativamente todo el *heap* hasta que no hayan más celdas para visitar (con el bit *scan* activo):: function mark_heap() is - while more_to_scan - more_to_scan = false + while global more_to_scan + global more_to_scan = false foreach pool in heap foreach page in pool if page.block_size <= PAGE // saltea FREE y CONTINUATION @@ -577,15 +594,11 @@ celdas para visitar (con el bit *scan* activo):: if block.scan is true block.scan = false if page.block_size is PAGE // objeto grande - start = cast(byte*) page + begin = cast(byte*) page end = find_big_object_end(pool, page) - foreach word in start..end - pointer = cast(void*) word - mark(pointer) + mark_range(begin, end) else // objeto pequeño - foreach word in block - pointer = cast(void*) word - mark(pointer) + mark_range(block.begin, block.end) Aquí puede verse, con un poco de esfuerzo, la utilización de la :ref:`abstracción tricolor `: todas las celdas alcanzables @@ -665,9 +678,9 @@ objetos grandes se marcan todas las páginas que utilizaban como ``FREE``:: function free_big_object(pool, page) is pool_end = cast(byte*) pool.pages + (PAGE_SIZE * pool.number_of_pages) do - page = cast(byte*) page + PAGE_SIZE page.block_size = FREE - while page.block_size is CONTINUATION and page < pool_end + page = cast(byte*) page + PAGE_SIZE + while page < pool_end and page.block_size is CONTINUATION Además, los bloques que tienen en atributo ``final`` son finalizados llamando a la función ``finalize()``. Esta función es un servicio que provee la @@ -746,16 +759,15 @@ suficientemente grande como para poder almacenar el tamaño solicitado). Una vez más el algoritmo distingue objetos grandes de pequeños. Los pequeños se asignan de las siguiente manera:: - function new_small(block_size) is + function new_small(block_size) is + block = find_block_with_size(block_size) + if block is null + collect() block = find_block_with_size(block_size) if block is null - collect() + new_pool() block = find_block_with_size(block_size) - if block is null - new_pool() - block = find_block_with_size(block_size) - return null - return block + return block Se intenta reiteradas veces conseguir un bloque del tamaño correcto libre, realizando diferentes acciones si no se tiene éxito. Primero se intenta hacer @@ -765,39 +777,41 @@ pidiendo memoria al *low level allocator* (el sistema operativo generalmente). Para intentar buscar un bloque de memoria libre se realiza lo siguiente:: - function find_block_with_size(block_size) is + function find_block_with_size(block_size) is + block = free_lists[block_size].pop_first() + if block is null + assign_page(block_size) block = free_lists[block_size].pop_first() - if block is null - assign_page(block_size) - block = free_lists[block_size].pop_first() - return block + return block Si no se puede obtener un bloque de la lista de libres correspondiente, se busca asignar una página libre al tamaño de bloque deseado de forma de *alimentar* la lista de libres con dicho tamaño:: - function assign_page(block_size) is - foreach pool in heap - foreach page in pool - if page.block_size is FREE - page.block_size = block_size - foreach block in page - free_lists[page.block_size].link(block) + function assign_page(block_size) is + foreach pool in heap + foreach page in pool + if page.block_size is FREE + page.block_size = block_size + foreach block in page + free_lists[page.block_size].link(block) Cuando todo ello falla, el último recurso consiste en pedir memoria al sistema operativo, creando un nuevo *pool*:: - funciones new_pool(number_of_pages = 1) is - pool = alloc(pool.sizeof) - if pool is null - return null - pool.number_of_pages = number_of_pages - pool.pages = alloc(number_of_pages * PAGE_SIZE) - if pool.pages is null - free(pool) - return null - heap.add(pool) - return pool + function new_pool(number_of_pages = 1) is + pool = alloc(pool.sizeof) + if pool is null + return null + pool.number_of_pages = number_of_pages + pool.pages = alloc(number_of_pages * PAGE_SIZE) + if pool.pages is null + free(pool) + return null + heap.add(pool) + foreach page in pool + page.block_size = FREE + return pool Se recuerda que la función ``alloc()`` es un :ref:`servicio ` provisto por el *low level allocator* y en la @@ -813,22 +827,22 @@ Si el tamaño de bloque necesario para cumplir con la asignación de memoria es de una página, entonces se utiliza otro algoritmo para alocar un objeto grande:: - function new_big(size) is - number_of_pages = ceil(size / PAGE_SIZE) + function new_big(size) is + number_of_pages = ceil(size / PAGE_SIZE) + pages = find_pages(number_of_pages) + if pages is null + collect() pages = find_pages(number_of_pages) if pages is null - collect() - pages = find_pages(number_of_pages) - if pages is null - minimize() - pool = new_pool(number_of_pages) - if pool is null - return null - pages = assign_pages(pool, number_of_pages) - pages[0].block_size = PAGE - foreach page in pages[1..end] - page.block_size = CONTINUATION - return pages[0] + minimize() + pool = new_pool(number_of_pages) + if pool is null + return null + pages = assign_pages(pool, number_of_pages) + pages[0].block_size = PAGE + foreach page in pages[1..end] + page.block_size = CONTINUATION + return pages[0] De forma similar a la asignación de objetos pequeños, se intenta encontrar una serie de páginas contiguas, dentro de un mismo *pool*, suficientes para @@ -854,34 +868,34 @@ completamente libres:: Volviendo a la función ``new_big()``, para hallar una serie de páginas contiguas se utiliza el siguiente algoritmo:: - function find_pages(number_of_pages) is - foreach pool in heap - pages = assign_pages(pool, number_of_pages) - if pages - return pages - return null + function find_pages(number_of_pages) is + foreach pool in heap + pages = assign_pages(pool, number_of_pages) + if pages + return pages + return null Como se dijo, las páginas deben estar contenidas en un mismo *pool* (para tener la garantía de que sean contiguas), por lo tanto se busca *pool* por *pool* dicha cantidad de páginas libres consecutivas a través del siguiente algoritmo:: - function assign_pages(pool, number_of_pages) is - pages_found = 0 - first_page = null - foreach page in pool - if page.block_size is FREE - if pages_found is 0 - pages_found = 1 - first_page = page - else - pages_found = pages_found + 1 - if pages_found is number_of_pages - return [first_page .. page] + function assign_pages(pool, number_of_pages) is + pages_found = 0 + first_page = null + foreach page in pool + if page.block_size is FREE + if pages_found is 0 + pages_found = 1 + first_page = page else - pages_found = 0 - first_page = null - return null + pages_found = pages_found + 1 + if pages_found is number_of_pages + return [first_page .. page] + else + pages_found = 0 + first_page = null + return null Una vez más, cuando todo ello falla (incluso luego de una recolección), se intenta alocar un nuevo *pool*, esta vez con una cantidad de páginas @@ -951,22 +965,20 @@ El recolector está principalmente contenido en la estructura llamada ``Gcx``. Dicha estructura tiene los siguientes atributos (divididos en categorías para facilitar la comprensión): -**Raíces definidas por el usuario** - - *roots* (*nroots*, *rootdim*): +Raíces definidas por el usuario + *roots* (*nroots*, *rootdim*) arreglo variable de punteros simples que son tomados como raíces provistas por el usuario. - *ranges* (*nranges*, *rangedim*): + *ranges* (*nranges*, *rangedim*) arreglo variable de rangos de memoria que deben ser revisados (de forma conservativa) como raíces provistas por el usuario. Un rango es una estructura con dos punteros: ``pbot`` y ``ptop``. Toda la memoria entre estos dos punteros se toma, palabra por palabra, como una raíz del recolector. -**Estado interno del recolector** - - *anychanges*: +Estado interno del recolector + *anychanges* variable que indica si en la fase de marcado se encontraron nuevas celdas con punteros que deban ser visitados. Otra forma de verlo es como un indicador de si el conjunto de celdas *grises* está vacío luego de @@ -974,36 +986,35 @@ facilitar la comprensión): `). Es análoga a la variable ``more_to_scan`` presentada en :ref:`dgc_algo_mark`. - *inited*: + *inited* indica si el recolector fue inicializado. - *stackBottom*: + *stackBottom* puntero a la base del *stack* (asumiendo que el stack crece hacia arriba). Se utiliza para saber por donde comenzar a visitar el *stack* de forma conservativa, tomándolo con una raíz del recolector. - *Pools* (*pooltable*, *npools*): + *Pools* (*pooltable*, *npools*) arreglo variable de punteros a estructuras ``Pool`` (ver más adelante). Este arreglo se mantiene siempre ordenado de menor a mayor según la dirección de memoria de la primera página que almacena. - *bucket*: + *bucket* listas de libres. Es un arreglo de estructuras ``List`` utilizadas para guardar la listas de libres de todos los tamaños de bloques posibles (ver más adelante). -**Atributos que cambian el comportamiento** - - *noStack*: +Atributos que cambian el comportamiento + *noStack* indica que no debe tomarse al *stack* como raíz del recolector. Esto es muy poco seguro y no debería ser utilizado nunca, salvo casos extremadamente excepcionales. - *log*: + *log* indica si se debe guardar un registro de la actividad del recolector. Es utilizado principalmente para depuración. - *disabled*: + *disabled* indica que no se deben realizar recolecciones implícitamente. Si al tratar de asignar memoria no se puede hallar celdas libres en el *heap* del recolector, se pide más memoria al sistema operativo sin correr una @@ -1012,16 +1023,15 @@ facilitar la comprensión): se pueden tolerar grandes pausas como las que puede provocar el recolector. -**Optimizaciones** - - *p_cache*, *size_cache*: +Optimizaciones + *p_cache*, *size_cache* obtener el tamaño de un bloque dado un puntero es una tarea costosa y común. Para evitarla en casos donde se calcula de forma sucesiva el tamaño del mismo bloque (como puede ocurrir al concatenar arreglos dinámicos) se guarda el último calculado en estas variables a modo de *caché*. - *minAddr*, *maxAddr*: + *minAddr*, *maxAddr* punteros al principio y fin del *heap*. Pueden haber *huecos* entre estos dos punteros que no pertenezcan al *heap* pero siempre se cumple que si un puntero apunta al *heap* debe estar en este rango. Esto es @@ -1048,29 +1058,29 @@ C ``malloc()``, ``realloc()`` y ``free()`` directamente. La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura :vref:`fig:dgc-pool`): -*baseAddr* y *topAddr*: +*baseAddr* y *topAddr* punteros al comienzo y fin de la memoria que almacena todas las páginas del *pool* (*baseAddr* es análogo al atributo *pages* utilizado en las secciones anteriores para mayor claridad). -*mark*, *scan*, *freebits*, *finals*, *noscan*: +*mark*, *scan*, *freebits*, *finals*, *noscan* conjunto de bits (*bitsets*) para almacenar los indicadores descriptos en :ref:`dgc_org` para todos los bloques de todas las páginas del *pool*. *freebits* es análogo a *free* y *finals* a *final* en los atributos descriptos en las secciones anteriores. -*npages*: +*npages* cantidad de páginas que contiene este *pool* (fue nombrado *number_of_pages* en las secciones anteriores para mayor claridad). -*ncommitted*: +*ncommitted* cantidad de páginas *encomendadas* al sistema operativo (*committed* en inglés). Este atributo no se mencionó anteriormente porque el manejo de páginas encomendadas le agrega una complejidad bastante notable al recolector y es solo una optimización para un sistema operativo en particular (Microsoft Windows). -*pagetable*: +*pagetable* arreglo de indicadores de tamaño de bloque de cada página de este *pool*. Los indicadores válidos son ``B_16`` a ``B_2048`` (pasando por los valores posibles de bloque mencionados anteriormente, todos con el prefijo @@ -1144,56 +1154,54 @@ A continuación se resumen las funciones principales, separadas en categorías para facilitar la comprensión. Los siguientes son métodos de la estructura ``Gcx``: -**Inicialización y terminación** - - *initialize()*: +Inicialización y terminación + *initialize()* inicializa las estructuras internas del recolector para que pueda ser utilizado. Esta función la llama la biblioteca *runtime* antes de que el programa comience a correr. - *Dtor()*: + *Dtor()* libera todas las estructuras que utiliza el recolector. -**Manipulación de raíces definidas por el usuario** - - *addRoot(p)*, *removeRoot(p)*, *rootIter(dg)*: +Manipulación de raíces definidas por el usuario + *addRoot(p)*, *removeRoot(p)*, *rootIter(dg)* agrega, remueve e itera sobre las raíces simples definidas por el usuario. - *addRange(pbot, ptop)*, *remove range(pbot)*, *rangeIter(dg)*: + *addRange(pbot, ptop)*, *remove range(pbot)*, *rangeIter(dg)* agrega, remueve e itera sobre los rangos de raíces definidas por el usuario. -**Manipulación de indicadores** - - Cada bloque (*bin* en la terminología de la implementación del recolector) - tiene ciertos indicadores asociados. Algunos de ellos pueden ser - manipulados (indirectamente) por el usuario utilizando estas funciones: - - *getBits(pool, biti)*: +Manipulación de indicadores + *getBits(pool, biti)* obtiene los indicadores especificados para el bloque de índice ``biti`` en el *pool* ``pool``. - *setBits(pool, biti, mask)*: + *setBits(pool, biti, mask)* establece los indicadores especificados en ``mask`` para el bloque de índice ``biti`` en el *pool* ``pool``. - *clrBits(pool, biti, mask)*: + *clrBits(pool, biti, mask)* 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) + tiene ciertos indicadores asociados. Algunos de ellos pueden ser + manipulados (indirectamente) por el usuario utilizando las funciones + mencionadas arriba. + El parámetro ``mask`` debe ser una máscara de bits que puede estar compuesta por la conjunción de los siguientes valores: - *FINALIZE*: + *FINALIZE* el objeto almacenado en el bloque tiene un destructor (indicador *finals*). - *NO_SCAN*: + *NO_SCAN* el objeto almacenado en el bloque no contiene punteros (indicador *noscan*). - *NO_MOVE*: + *NO_MOVE* el objeto almacenado en el bloque no debe ser movido [#dgcmove]_. .. [#dgcmove] Si bien el recolector actual no tiene la capacidad de mover @@ -1202,44 +1210,39 @@ para facilitar la comprensión. Los siguientes son métodos de la estructura fijar objetos apuntados desde algún segmento no conservativo (objeto *pinned*). -**Búsquedas** - - *findPool(p)*: +Búsquedas + *findPool(p)* busca el *pool* al que pertenece el objeto apuntado por ``p``. - *findBase(p)*: + *findBase(p)* busca la dirección base (el inicio) del bloque apuntado por ``p`` (``find_block()`` según la sección :ref:`dgc_algo_mark`). - *findSize(p)*: + *findSize(p)* busca el tamaño del bloque apuntado por ``p``. - *getInfo(p)*: + *getInfo(p)* obtiene información sobre el bloque apuntado por ``p``. Dicha información se retorna en una estructura ``BlkInfo`` que contiene los siguientes atributos: ``base`` (dirección del inicio del bloque), ``size`` (tamaño del bloque) y ``attr`` (atributos o indicadores del bloque, los que se pueden obtener con ``getBits()``). - *findBin(size)*: + *findBin(size)* calcula el tamaño de bloque más pequeño que pueda contener un objeto de tamaño ``size`` (``find_block_size()`` según lo visto en :ref:`dgc_algo_alloc`). -**Asignación de memoria** - - Recordar que la ``pooltable`` siempre se mantiene ordenada según la - dirección de la primera página. - - *reserve(size)*: +Asignación de memoria + *reserve(size)* reserva un nuevo *pool* de al menos ``size`` bytes. El algoritmo nunca crea un *pool* con menos de 256 páginas (es decir, 1 MiB). - *minimize()*: + *minimize()* minimiza el uso de la memoria retornando *pools* sin páginas usadas al sistema operativo. - *newPool(n)*: + *newPool(n)* reserva un nuevo *pool* con al menos ``n`` páginas. Junto con ``Pool.initialize()`` es análoga a ``new_pool()``, solo que esta función siempre incrementa el número de páginas a, al menos, 256 páginas (es @@ -1251,7 +1254,7 @@ para facilitar la comprensión. Los siguientes son métodos de la estructura 3 MiB y así sucesivamente hasta 8 MiB. A partir de ahí siempre crea *pools* de 8 MiB o la cantidad pedida, si ésta es mayor. - *Pool.initialize(n_pages)*: + *Pool.initialize(n_pages)* inicializa un nuevo *pool* de memoria. Junto con ``newPool()`` es análoga a ``new_pool()``. Mientras ``newPool()`` es la encargada de calcular la cantidad de páginas y crear el objeto *pool*, esta función @@ -1261,23 +1264,23 @@ para facilitar la comprensión. Los siguientes son métodos de la estructura atributo ``FINALIZE`` a un bloque, se inicializa el conjunto de bits ``finals`` de todo el *pool*. - *allocPage(bin)*: + *allocPage(bin)* asigna a una página libre el tamaño de bloque ``bin`` y enlaza los nuevos bloques libres a la lista de libres correspondiente (análogo a ``assign_page()``). - *allocPages(n)*: + *allocPages(n)* Busca ``n`` cantidad de páginas consecutivas libres (análoga a ``find_pages(n)``). - *malloc(size, bits)*: + *malloc(size, bits)* asigna memoria para un objeto de tamaño ``size`` bytes. Análoga al algoritmo ``new(size, attr)`` presentado, excepto que introduce además un caché para no recalcular el tamaño de bloque necesario si se realizan múltiples asignaciones consecutivas de objetos del mismo tamaño y que la asignación de objetos pequeños no está separada en una función aparte. - *bigAlloc(size)*: + *bigAlloc(size)* asigna un objeto grande (análogo a ``new_big()``). La implementación es mucho más compleja que la presentada en ``new_big()``, pero la semántica es la misma. La única diferencia es que esta función aprovecha que @@ -1286,19 +1289,19 @@ para facilitar la comprensión. Los siguientes son métodos de la estructura el caso en que no se liberaron suficientes páginas para asignar el objeto grande y pasar directamente a crear un nuevo *pool*. - *free(p)*: + *free(p)* libera la memoria apuntada por ``p`` (análoga a ``delete()`` de la sección anterior). -**Recolección** + Recordar que la ``pooltable`` siempre se mantiene ordenada según la + dirección de la primera página. - *mark(pbot, ptop)*: - marca un rango de memoria. Este método es análogo al ``mark()`` - presentado en la sección :ref:`dgc_algo_mark` pero marca un rango - completo de memoria, lo que permite que sea considerablemente más - eficiente. +Recolección + *mark(pbot, ptop)* + marca un rango de memoria. Este método es análogo al ``mark_range()`` + presentado en la sección :ref:`dgc_algo_mark`. - *fullcollectshell()*: + *fullcollectshell()* guarda los registros en el *stack* y llama a ``fullcollect()``. El algoritmo presentado en :ref:`dgc_algo_mark` es simbólico, ya que si los registros se apilaran en el *stack* dentro de otra función, al salir de @@ -1306,7 +1309,7 @@ para facilitar la comprensión. Los siguientes son métodos de la estructura función ``collect()`` o en una función que luego la llame (como en este caso). - *fullcollect(stackTop)*: + *fullcollect(stackTop)* realiza la recolección de basura. Es análoga a ``collect()`` pero es considerablemente menos modular, todos los pasos se hacen directamente en esta función: marcado del *root set*, marcado iterativo del *heap*, @@ -1328,6 +1331,8 @@ a ningún destructor), para el usuario puede ser una garantía muy débil y proveer finalización asegurada puede ser muy deseable. +.. _dgc_committed: + Memoria *encomendada* ^^^^^^^^^^^^^^^^^^^^^ El algoritmo actual divide un *pool* en dos áreas: memoria *encomendada* @@ -1432,6 +1437,73 @@ utiliza conjuntos de bits. Esto trae dos ventajas principales: considerablemente la fase de marcado. +.. _dgc_debug: + +Herramientas para depuración +^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +El recolector provee algunas opciones para simplificar el diagnóstico +y depuración de problemas, tanto del mismo recolector como del programa del +usuario. + +Las opciones más importantes son: + + +``MEMSTOMP`` + Su función es escribir un patrón determinado de bits en todos los bytes de + un bloque de memoria según se haya: + + * Pedido un bloque menor a una página (``0xF0``). + * Pedido un bloque mayor a una página (``0xF1``). + * Dejado de usar debido a un pedido de achicamiento de un bloque + (``0xF2``). + * Pedido más páginas debido a un pedido de agrandamiento de un bloque + (``0xF0``). + * Liberado intencionalmente por el usuario (``0xF2``). + * Barrido (``0xF3``). + + Esto permite al diagnosticar un problema saber, por ejemplo, si un + determinado área de memoria fue recolectada recientemente, o liberada por + el usuario, o recién adquirida, etc. con tan solo ver si un patrón de bits + determinado está presente. Por supuesto puede existir *falsos positivos* + pero su probabilidad es lo suficientemente baja como para que sea útil en + la práctica. + +``SENTINEL`` + Su función detectar errores producidos por escribir más allá (o antes) del + área de memoria solicitada y está implementado reservando un poco más de + memoria de la que pide el usuario, devolviendo un puntero a un bloque + ubicado dentro del bloque real reservado (en vez de al inicio) y finalmente + escribiendo un patrón de bits en los extremos del borde real (ver figura + :vref:`fig:sentinel`), de forma de poder verificar en distintas situación + (por ejemplo al barrer el bloque) que esas áreas de más con los patrones de + bits estén intactas. Esto permite detectar de forma temprana errores tanto + en el recolector como en el programa del usuario. + + .. fig:: fig:sentinel + + Esquema de un bloque cuando está activada la opción ``SENTINEL``. + + .. aafig:: + :textual: + + | | | | | + +-- Palabra ---+-- Palabra ---+-- Tamaño bloque de usuario --+- Byte -+ + | | | | | + + +--------------+--------------+------------------------------+--------+ + | "Tamaño del" | Pre | | Post | + | "bloque de" | | Bloque de usuario | | + | "usuario" | 0xF4F4F4F4 | | 0xF5 | + +--------------+--------------+------------------------------+--------+ + A + | + Puntero devuleto ---/ + +Ambas opciones son seleccionables sólo en tiempo de compilación del +recolector, por lo que su utilidad real, al menos para el usuario, se ve +severamente reducida. + .. _dgc_bad: @@ -1445,6 +1517,8 @@ participación y observación del grupo de noticias, de donde se obtuvieron los principales problemas percibidos por la comunidad que utiliza el lenguaje. +.. _dgc_bad_code: + Complejidad del código y documentación ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ El análisis del código fue muy complicado debido a la falta de documentación @@ -1593,8 +1667,8 @@ y en particular para mejorar la implementación de de arreglos asociativos. Referencias débiles ^^^^^^^^^^^^^^^^^^^ El recolector actual no dispone de soporte de *referencias débiles* -[#dgcweakref]_, sin embargo hay una demanda [NGD86840]_ [NGD13301]_ [NGL8264]_ -[NGD69761]_ [NGD74624]_ [NGD88065]_ +[#dgcweakref]_, sin embargo hay una demanda apreciable [NGD86840]_ [NGD13301]_ +[NGL8264]_ [NGD69761]_ [NGD74624]_ [NGD88065]_. .. [#dgcweakref] Una referencia débil (o *weak reference* en inglés) es aquella que que no protege al objeto referenciado de ser reciclado por el @@ -1603,7 +1677,7 @@ El recolector actual no dispone de soporte de *referencias débiles* Para cubrir esta demanda, se han implementado soluciones como biblioteca para suplir la inexistencia de una implementación oficial [NGA9103]_. -Sin embargo éstas son en general poco robustas y extremadamente dependientes +Sin embargo éstas son en general poco robustas, extremadamente dependientes de la implementación del recolector y, en general, presentan problemas muy sutiles [NGD88065]_. Por esta razón se ha discutido la posibilidad de incluir la implementación de *referencias débiles* como parte del lenguaje @@ -1671,18 +1745,49 @@ 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. +Configurabilidad +^^^^^^^^^^^^^^^^ +Si bien el recolector actual tiene algunas características configurables, +todas son seleccionables sólo en tiempo de compilación del recolector (no del +programa del usuario), como por ejemplo las opciones descriptas en +:ref:`dgc_debug`. Por lo tanto, a nivel práctico, es como si no tuviera +posibilidad alguna de ser configurado por el usuario, ya que no es parte del +ciclo de desarrollo normal el recompilar el recolector o *runtime* de un +lenguaje. + +Dado que es imposible que un recolector sea óptimo para todo tipo de +programas, es muy deseable permitir una configuración de parámetros del +recolector que permitan al usuario ajustarlo a las necesidades particulares de +sus programas. + + +.. _dgc_bad_ocup: + +Factor de ocupación del *heap* +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Otro problema potencialmente importante del recolector actual es que no se +tiene ningún cuidado con respecto a que, luego de una recolección, se haya +recuperado una buena parte del *heap*. Por lo tanto, en casos extremos, el +recolector tiene que hacer una recolección por cada petición de memoria, lo +que es extremadamente ineficiente. + +Para evitar esto, habría que usar algún esquema para evaluar cuando una +recolección no fue lo suficientemente *exitosa* y en ese caso pedir más +memoria al sistema operativo. + + Detalles ^^^^^^^^ Finalmente hay varios detalles en la implementación actual que podrían mejorarse: -Listas de libres: +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 para indicadores: +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, @@ -1697,21 +1802,21 @@ Conjuntos de bits para indicadores: objeto grande; lo que equivaldría al 2560 objetos de 16 bytes desperdiciados en bits inutilizados). -Repetición de código: +Repetición de código Hay algunos fragmentos de código repetidos innecesariamente. Por ejemplo en varios lugares se utilizan arreglos de tamaño variable que se implementan repetidas veces (en general como un puntero al inicio del arreglo más el tamaño actual del arreglo más el tamaño de la memoria total asignada actualmente). Esto es propenso a errores y difícil de mantener. -Uso de señales: +Uso de señales el recolector actual utiliza las señales del sistema operativo ``SIGUSR1`` y ``SIGUSR2`` para pausar y reanudar los hilos respectivamente. Esto puede traer inconvenientes a usuarios que desean utilizar estas señales en sus programas (o peor aún, si interactúan con bibliotecas de C que hacen uso de estas señales) [NGD5821]_. -Marcado iterativo: +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 @@ -1720,4 +1825,4 @@ Marcado iterativo: .. include:: links.rst -.. vim: set ts=3 sts=3 sw=3 et tw=78 : +.. vim: set ts=3 sts=3 sw=3 et tw=78 spelllang=es :