2 .. Describe más detalladamente los problemas actuales del recolector de
3 basura de D, sentando las bases para el análisis de los requerimientos
4 de recolección de basura en dicho lenguaje (se explica por qué las
5 particularidades descriptas en la sección anterior complican la
6 recolección de basura y cuales son las que más molestan).
7 ESTADO: SIN EMPEZAR, REVISAR LO HECHO
12 Recolección de basura en D
13 ============================================================================
19 Dificultades para recolectar basura en D
20 ----------------------------------------------------------------------------
28 Recolector de basura actual de D
29 ----------------------------------------------------------------------------
31 Como paso básico fundamental para poder mejorar el recolector de basura de D_,
32 primero hay que entender la implementación actual, de forma de conocer sus
33 puntos fuertes, problemas y limitaciones, de manera tal de poder analizar
36 Como se mencionó en la sección :ref:`d_lang`, en D_ hay dos bibliotecas base
37 para soportar el lenguaje (*runtimes*): Phobos_ y Tango_. La primera es la
38 biblioteca estándar de D_, la segunda un proyecto más abierto y dinámico que
39 surgió como alternativa a Phobos_ debido a que Phobos_ es muy desprolija y que
40 era muy difícil impulsar cambios en ella. Ahora Phobos_ tiene el agravante de
41 estar *congelada* en su versión 1 (solo se realizan correcciones de errores).
43 Dado que Tango_ está mejor organizada, su desarrollo es más abierto (aceptan
44 cambios y mejoras) y que hay una mayor disponibilidad de programas
45 y bibliotecas escritos para Tango_, en este trabajo se decide tomar esta
46 biblioteca *runtime* como base para el análisis y mejoras propuestas, a pesar
47 de ser Phobos_ la estándar. De todas formas el recolector de basura de Tango_
48 es prácticamente el mismo que el de Phobos_, por lo tanto éste análisis en
49 particular es válido para cualquiera de las dos.
51 El recolector actual es un recolector :ref:`indirecto <gc_direct>`, :ref:`no
52 incremental <gc_inc>` que realiza un :ref:`marcado y barrido <gc_mark_sweep>`
53 relativamente básico. A diferencia del algoritmo clásico presentado éste
54 realiza un marcado no recursivo. La fase de marcado es :ref:`stop-the-world
55 <gc_concurrent` mientras que la fase de barrido corre en paralelo con el
56 *mutator*, excepto el hilo que disparó la recolección que es quien efectúa el
57 barrido (además los hilos que intenten asignar nueva memoria o interactuar con
58 el recolector de cualquier otra forma se bloquean hasta que la fase de barrido
59 concluya). El marcado es casi totalmente :ref:`conservativo <gc_conserv>`; si
60 bien posee alguna información de tipos (distingue entre celdas que pueden
61 tener punteros y celdas que definitivamente no los tienen, pero no dispone de
62 información sobre qué campos de las celdas son punteros y cuales no). Además
63 no tiene soporte alguno de :ref:`recolección particionada <gc_part>`.
65 Si bien el recolector es bastante básico, posee una :ref:`organización de
66 memoria <dgc_org>` relativamente moderna (utiliza una :ref:`lista de libres
67 <gc_free_list>` con un *two level allocator*) y algunas optimizaciones
68 particulares para amortiguar casos patológicos.
73 Organización del *heap*
74 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
76 La memoria del *heap* está organizada en *pools*. Un *pool* es una región de
77 *páginas* contíguas. Una página es, en general, la unidad mínima de memoria que
78 maneja un sistema operativo con soporte de memoria virtual. Cada página dentro
79 de un *pool* sirve a su vez como contenedora de bloques (llamados *bin* en la
80 :ref:`implementación <dgc_impl>`) de tamaño fijo. Todos los bloques
81 pertenecientes a la misma página tienen el mismo tamaño de bloque (ver figura
82 :vref:`fig:dgc-org`). Los tamaños de bloque posibles son potencias de 2 desde
83 16 bytes hasta 4096 (el tamaño típico de una página), es decir: 16, 32, 64,
84 128, 256, 512, 1024, 2048 y 4096 [#dgcpageplus]_. Todos los objetos, arreglos
85 o celdas en general se ubican en estos bloques (en uno del tamaño más pequeño
86 que haya que sea suficientemente grande como para almacenar dicho objeto). En
87 caso de que un objeto sea mayor a una página, se utilizan la menor cantidad de
88 páginas contíguas de un pool que tengan espacio suficiente para almacenar
91 .. [#dgcpageplus] Además existe otro tamaño de bloque especial que se utiliza
92 para indicar la continuación de un objeto grande (que ocupan más de una
97 Organización del *heap* del recolector de basura actual de D.
99 Organización del *heap*. En este ejemplo todos los *pools* tienen 2 páginas
100 excepto el *pool* 2 que tiene una sola. El tamaño de bloque que almacena
101 cada página varía entre 64 bytes (página 0 del *pool* 2) hasta 4096 (ambas
102 páginas del *pool* N) que es una página completa.
107 +----------------------------------------------------------------------+
109 +======================================================================+
110 | "Pool 0" "Pool 1" "Pool 2" "Pool 3" ... "Pool N" |
111 | +----------+ +----------+ +----------+ +----------+ +----------+ |
112 | | Página 0 | | Página 0 | | Página 0 | | Página 0 | ... | Página 0 | |
113 | | (8x512) | | (4x1024) | | (64x64) | | (2x2048) | ... | (1x4096) | |
114 | |+--------+| |+--------+| |+--------+| |+--------+| |+--------+| |
115 | || Bloque || || || ||qqqqqqqq|| || || || || |
116 | |+--------+| || Bloque || ||qqqqqqqq|| || || || || |
117 | || Bloque || || || ||qqqqqqqq|| || || || || |
118 | |+--------+| |+--------+| ||qqqqqqqq|| || Bloque || || || |
119 | || Bloque || || || ||qqqqqqqq|| || || || || |
120 | |+--------+| || Bloque || ||qqqqqqqq|| || || || || |
121 | || Bloque || || || ||qqqqqqqq|| || || || || |
122 | |+--------+| |+--------+| ||qqqqqqqq|| |+--------+| || Bloque || |
123 | || Bloque || || || ||qqqqqqqq|| || || || || |
124 | |+--------+| || Bloque || ||qqqqqqqq|| || || || || |
125 | || Bloque || || || ||qqqqqqqq|| || || || || |
126 | |+--------+| |+--------+| ||qqqqqqqq|| || Bloque || || || |
127 | || Bloque || || || ||qqqqqqqq|| || || || || |
128 | |+--------+| || Bloque || ||qqqqqqqq|| || || || || |
129 | || Bloque || || || ||qqqqqqqq|| || || || || |
130 | |+--------+| |+--------+| |+--------+| |+--------+| |+--------+| |
131 | | Página 1 | | Página 1 | +----------+ | Página 1 | ... | Página 1 | |
132 | | (16x256) | | (8x512) | | (32x128) | ... | (1x4096) | |
133 | |+--------+| |+--------+| |+--------+| |+--------+| |
134 | |+--------+| || Bloque || ||nnnnnnnn|| || || |
135 | |+--------+| |+--------+| ||nnnnnnnn|| || || |
136 | |+--------+| || Bloque || ||nnnnnnnn|| || || |
137 | |+--------+| |+--------+| ||nnnnnnnn|| || || |
138 | |+--------+| || Bloque || ||nnnnnnnn|| || || |
139 | |+--------+| |+--------+| ||nnnnnnnn|| || || |
140 | |+--------+| || Bloque || ||nnnnnnnn|| || || |
141 | |+--------+| |+--------+| ||nnnnnnnn|| || Bloque || |
142 | |+--------+| || Bloque || ||nnnnnnnn|| || || |
143 | |+--------+| |+--------+| ||nnnnnnnn|| || || |
144 | |+--------+| || Bloque || ||nnnnnnnn|| || || |
145 | |+--------+| |+--------+| ||nnnnnnnn|| || || |
146 | |+--------+| || Bloque || ||nnnnnnnn|| || || |
147 | |+--------+| |+--------+| ||nnnnnnnn|| || || |
148 | |+--------+| || Bloque || ||nnnnnnnn|| || || |
149 | |+--------+| |+--------+| |+--------+| ... |+--------+| |
150 | +----------+ +----------+ +----------+ +----------+ |
151 +----------------------------------------------------------------------+
153 Cada página de un *pool* puede estar asignada a contener bloques de un tamaño
154 específico o puede estar libre. A su vez, cada bloque puede estar ocupado por
155 una celda o estar libre. Los bloques libres de un tamaño específico (a
156 excepción de aquellos bloques que ocupen una página entera) además forman
157 parte de una :ref:`lista de libres <gc_free_list>` (ver figura
158 :vref:`fig:dgc-free-list`). Esto permite asignar objetos relativamente
159 pequeños de forma bastante eficiente.
161 .. fig:: fig:dgc-free-list
163 Ejemplo de listas de libres.
165 .. digraph:: dgc_free_list
171 node [ shape = record, width = 0, height = 0 ];
173 subgraph cluster_heap {
177 free [ label = "Libres|<p16> 16|<p32> 32|<p64> 64|<p128> 128|<p256> 256|<p512> 512|<p1024> 1024|<p2048> 2048" ];
179 free:p16 -> b1 -> b2 -> b3;
180 free:p32 -> b4 -> b5 -> b6 -> b7 -> b8;
183 free:p256 -> b10 -> b11;
185 free:p1024 -> b13 -> b14;
186 free:p2048 -> b15 -> b16 -> b17;
192 Cada *pool* tiene la siguiente información asociada:
195 cantidad de páginas que tiene. Esta cantidad es fija en toda la vida de un
199 bloque de memoria contíguo de tamaño ``PAGE_SIZE * number_of_pages``
200 (siendo ``PAGE_SIZE`` el tamaño de página, que normalmente son 4096 bytes).
205 Cada página dentro de un *pool* tiene un único atributo asociado: *block_size*.
206 Se trata del tamaño de los bloques que almacena esta página.
208 Una página siempre almacena bloques del mismo tamaño, que pueden ser 16, 32,
209 64, 128, 256, 512, 1024, 2048 o 4096 (llamado con el nombre especial
210 ``PAGE``). Además hay dos tamaños de bloque símbólicos que tienen un
211 significado especial:
214 indica que la página está completamente libre y que la página está
215 disponible para albergar cualquier tamaño de bloque que sea necesario (pero
216 una vez que se le asignó un nuevo tamaño de bloque ya no puede ser cambiado
217 hasta que la página vuelva a liberarse por completo).
220 indica que esta página es la continuación de un objeto grande (es decir,
221 que ocupa una o más páginas). Luego se presentan más detalles sobre objetos
224 Las páginas con esto tamaños de bloque especiales (conceptualmente) no
230 Cada bloque tiene asociados varios atributos:
233 utilizado en la fase de :ref:`marcado <dgc_algo_mark>`, indica que un nodo
234 ya fue visitado (serían las celdas *negras* en la :ref:`abstracción
235 tricolor <gc_intro_tricolor>`).
238 utilizado también en la fase de :ref:`marcado <dgc_algo_mark>`, indica que
239 una celda visitada todavía tiene *hijas* sin marcar (serían las celdas
240 *grises* en la :ref:`abstracción tricolor <gc_intro_tricolor>`).
243 indica que el bloque está libre (no está siendo utilizado por ningún objeto
244 *vivo*). Esto es necesario solo por la forma en la que realiza el
245 :ref:`marcado <dgc_algo_mark>` y :ref:`barrido <dgc_algo_sweep>` en el
246 :ref:`algoritmo actual <dgc_algo>` (las celdas con el atributo este
247 atributo son tomadas como *basura* aunque estén marcadas con *mark*).
250 indica que el bloque contiene un objeto que tiene un destructor (que debe
251 ser llamado cuando la celda pasa de *viva* a *basura*).
254 indica que el bloque contiene un objeto que no tiene punteros y por lo
255 tanto no debe ser marcado de forma conservativa (no tiene *hijas*).
260 El recolector de basura actual de D_ trata de forma diferente a los objetos
261 grandes. Todo objeto grande empieza en un bloque con tamaño ``PAGE``
262 y (opcionalmente) continúa en los bloques contíguos subsiguientes que tengan
263 el tamaño de bloque ``CONTINUATION`` (si el objeto ocupa más que una página).
264 El fin de un objeto grande queda marcado por el fin del *pool* o una página
265 con tamaño de bloque distinto a ``CONTINUATION`` (lo que suceda primero).
267 Cuando un objeto grande se convierte en *basura*, todas sus páginas se liberan
268 por completo, siendo marcadas con tamaño ``FREE`` para que puedan ser
269 almacenado en ellas otros objetos grandes o incluso nuevos bloques de un
276 Algoritmos del recolector
277 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
279 A continuación se explica como provee el recolector actual de D_ los servicios
280 básicos que debe proveer cualquier recolector, como se presentó en la sección
281 :ref:`gc_intro_services`.
283 Cabe aclarar que se presenta una versión simplificada del algoritmo, o más
284 precisamente, de la implementación del algoritmo, ya que no se exponen en esta
285 sección muchas optimizaciones que harían muy compleja la tarea de explicar
286 como funciona conceptualmente. En la siguiente sección, :ref:`dgc_impl`, se
287 darán más detalles sobre las optimizaciones importantes y diferencias con el
288 algoritmo aquí presentado, junto con detalles sobre como se implementa la
289 organización del *heap* que se explicó en la sección anterior.
292 .. _dgc_algo_collect:
296 A grandes razgos el algoritmo de recolección puede resumirse de las dos fases
297 básicas de cualquier algoritmo de :ref:`marcado y barrido <gc_mark_sweep>`::
299 function collect() is
308 Esta fase consiste de varios pasos, que pueden resumirse en el siguiente
311 function mark_phase() is
314 clear_mark_scan_bits()
317 push_registers_into_stack()
323 La variable **global** ``more_to_scan`` indica al algoritmo iterativo cuando
324 debe finalizar: la función ``mark()`` (que veremos más adelante) lo pone en
325 ``true`` cuando una nueva celda debe ser visitada, por lo tanto la iteración
326 se interrumpe cuando no hay más celdas por visitar.
328 Las funciones ``stop_the_world()`` y ``start_the_world()`` sencillamente
329 pausan y reanudan todos los hilos respectivamente::
331 function stop_the_world() is
332 foreach thread in threads
335 function start_the_world() is
336 foreach thread in threads
339 La función ``clear_mark_scan_bits()`` se encarga de resetear todos los
340 atributos *mark* y *scan* de cada bloque del *heap*::
342 function clear_mark_scan_bits() is
345 foreach block in page
349 La función ``mark_free_lists()`` por su parte se encarga de activar el bit
350 *mark* de todos los bloques de las listas de libres de manera de que la fase
351 de marcado (que es iterativa y realiza varias pasadas sobre **todo** el
352 *heap*, incluyendo las celdas libres) no visite las celdas libres perdiendo
353 tiempo sin sentido y potencialmente manteniendo *vivas* celdas que en
354 realdidad son *basura* (falsos positivos)::
356 function mark_free_lists() is
357 foreach free_list in heap
358 foreach block in free_list
362 Notar que los bloques libres quedan entonces marcados aunque sean *basura* por
363 definición. Para evitar que en la etapa de barrido se tomen estos bloques como
364 celdas vivas, a todos los bloques en la lista de libres también se los marca
365 con el bit *free*, así el barrido puede tomar como *basura* estos bloques
366 aunque estén marcados.
368 El *root set* está compuesto por el área de memoria estática (variables
369 globales), los *stacks* de todos los hilos y los registros del procesador.
370 Primero se marca el área de memoria estática de manera :ref:`conservativa
371 <gc_conserv>` (es decir, tomando cada *word* como si fuera un puntero)::
373 function mark_static_data() is
374 foreach word in static_data
375 pointer = cast(void*) word
378 Para poder tomar los registros como parte del *root set* primero se apilan
379 en el *stack* a través de la función::
381 function push_registers_into_stack() is
382 foreach register in registers
385 Una vez hecho esto, basta marcar (de forma conservativa) los *stacks* de todos
386 los threads para terminar de marcar el *root set*::
388 function mark_stacks() is
389 foreach thread in threads
390 foreach word in thread.stack
391 pointer = cast(void*) word
394 Dado que D_ soporta manejo de memoria manual al mismo tiempo que memoria
395 automática, es posible que existan celdas de memoria que no estén en el *root
396 set* convencional ni en el *heap* del recolector. Para evitar que se libere
397 alguna celda que estaba siendo referenciada desde memoria administrada por el
398 usuario, éste debe informarle al recolector sobre la existencia de estoas
399 nuevas raíces. Es por esto que para concluir el marcado del *root set*
400 completo se procede a marcar las raíces definidas por el usuario::
402 function mark_user_roots() is
403 foreach pointer in user_roots
406 El algoritmo de marcado no es recursivo sino iterativo por lo tanto al marcar
407 una celda (o bloque) no se siguen sus *hijas*, solo se activa el bit de *scan*
408 (a menos que la celda no contenga punteros, es decir, tenga el bit *noscan*)::
410 function mark(pointer) is
411 [pool, page, block] = find_block(pointer)
412 if block is not null and block.mark is false
414 if block.noscan is false
418 Por lo tanto en este punto, tenemos todas las celdas inmediatamente
419 alcanzables desde el *root set* marcadas y con el bit *scan* activado si la
420 celda puede contener punteros. Por lo tanto solo resta marcar (nuevamente de
421 forma conservativa) iterativamente todo el *heap* hasta que no hayan más
422 celdas para visitar (con el bit *scan* activo)::
424 function mark_heap() is
429 if page.block_size <= PAGE // saltea FREE y CONTINUATION
430 foreach block in page
431 if block.scan is true
433 if page.block_size is PAGE // objeto grande
434 start = cast(byte*) page
435 end = find_big_object_end(pool, page)
436 foreach word in start..end
437 pointer = cast(void*) word
439 else // objeto pequeño
440 foreach word in block
441 pointer = cast(void*) word
444 Aquí puede verse, con un poco de esfuerzo, la utilización de la
445 :ref:`abtracción tricolor <gc_intro_tricolor>`: todas las celdas alcanzables
446 desde el *root set* son pintadas de *gris* (tienen los bits *mark* y *scan*
447 activados), excepto aquellas celdas atómicas (es decir, que se sabe que no
448 tienen punteros) que son marcadas directamente de *negro*. Luego se van
449 obteniendo celdas del conjunto de las *grises*, se las pinta de *negro* (es
450 decir, se desactiva el big *scan*) y se pintan todas sus *hijas* de *gris* (o
451 *negro* directamente si no tienen punteros). Este procedimiento se repite
452 mientras el conjunto de celdas *grises* no sea vacío (es decir, que
453 ``more_to_scan`` sea ``true``).
455 A continuación se presenta la implementación de las funciones suplementarias
456 utilizadas en la fase de marcado::
458 function find_big_object_end(pool, page) is
459 pool_end = cast(byte*) pool.pages + (PAGE_SIZE * pool.number_of_pages)
461 page = cast(byte*) page + PAGE_SIZE
462 while page.block_size is CONTINUATION and page < pool_end
465 function find_block(pointer) is
468 if page.block_size is PAGE
469 big_object_start = cast(byte*) page
470 big_object_end = find_big_object_end(pool, page)
471 if big_object_start <= pointer < big_object_end
472 return [pool, page, big_object_start]
473 else if page.bloc_size < PAGE
474 foreach block in page
475 block_start = cast(byte*) block
476 block_end = block_start + page.block_size
477 if block_start <= pointer < block_end
478 return [pool, page, block_start]
479 return [null, null, null]
481 Cabe destacar que la función ``find_block()`` devuelve el pool, la página y el
482 comienzo del bloque al que apunta el puntero, es decir, soporta punteros
490 Esta fase es considerablemente más sencilla que el marcado; el algoritmo puede
491 dividirse en dos pasos básicos::
493 function sweep_phase() is
497 El barrido se realiza con una pasada por sobre todo el *heap* de la siguiente
503 if page.block_size <= PAGE // saltea FREE y CONTINUATION
504 foreach block in page
505 if block.mark is false
506 if block.final is true
511 if page.block_size is PAGE // objeto grande
512 free_big_object(pool, page)
514 Como se observa, se recorre todo el *heap* en busca de bloques y páginas
515 libres. Los bloques libres son marcados con el atributo ``free`` y las páginas
516 libres son marcadas con el tamaño de bloque simbólico ``FREE``. Para los
517 objetos grandes se marcan todas las páginas que utilizaban como ``FREE``::
519 function free_big_object(pool, page) is
520 pool_end = cast(byte*) pool.pages + (PAGE_SIZE * pool.number_of_pages)
522 page = cast(byte*) page + PAGE_SIZE
523 page.block_size = FREE
524 while page.block_size is CONTINUATION and page < pool_end
526 Además, los bloques que tienen en atributo ``final`` son finalizados llamando
527 a la función ``finalize()``. Esta función es un servicio que provee la
528 biblioteca *runtime* y en última instancia llama al destructor del objeto
529 almacenado en el bloque a liberar.
531 Una vez marcados todos los bloques y páginas como libre, se procede
532 a reconstruir las listas de libres. En el proceso buscan las páginas que
533 tengan todos los bloques libres para marcar la página completa como libre (de
534 manera que pueda utilizarse para albergar otro tamaño de bloque u objetos
535 grandes de ser necesario)::
537 function rebuild_free_lists() is
538 foreach free_list in heap
542 if page.block_size < PAGE // objetos pequeños
543 if is_page_free(page)
544 page.block_size = FREE
546 foreach block in page
547 if block.free is true
548 free_lists[page.block_size].link(block)
550 Esta reorganización de listas libres además mejoran la localidad de
551 referencia y previenen la fragmentación. La localidad de referencia se ve
552 mojorada debido a que asignaciones de memoria proximas en el tiempo serán
553 también próximas en espacio porque pertenecerán a la misma página (al menos si
554 las asignaciones son todas del mismo tamaño). La fragmentación se minimiza por
555 el mismo efecto, primero se asignarán todos los bloques de la misma página.
557 A continuación se presenta la implementación de una de las funciones
558 suplementarias de la fase de barrido::
560 function is_page_free(page) is
561 foreach block in page
562 if block.free is false
566 Las demás funciones suplementarias pertenecen a la manipulación de listas
567 libres que no son más que operaciones sobre una lista simplemente enlazada. En
568 la sección :ref:`dgc_impl` se verá con más detalles como las implementa el
574 Asignación de memoria
575 ^^^^^^^^^^^^^^^^^^^^^
576 La asignación de memoria del recolector es relativamente compleja, excepto
577 cuando se asgina un objeto pequeño y ya existe algún bloque con el tamaño
578 preciso en la lista de libres. Para el resto de los casos la cantidad de
579 trabajo que debe hacer el recolector para asignar la memoria es considerable.
581 El algoritmo de asignación de memoria se puede resumir así::
583 function new(size, attrs) is
584 block_size = find_block_size(size)
586 block = new_small(block_size)
588 block = new_big(size)
595 return cast(void*) block
597 La función ``find_block_size()`` sencillamente busca el tamaño de bloque se
598 mejor se ajuste al tamaño solicitado (es decir, el bloque más pequeño lo
599 suficientemente grande como para poder almacenar el tamaño solicitado). Una
600 vez más el algoritmo distingue objetos grandes de pequeños. Los pequeños se
601 asginan de las siguiente manera::
603 function new_small(block_size) is
604 block = find_block_with_size(block_size)
607 block = find_block_with_size(block_size)
610 block = find_block_with_size(block_size)
614 Se intenta reiteradas veces conseguir un bloque del tamaño correcto libre,
615 realizando diferentes acciones si no se tiene éxito. Primero se intenta hacer
616 una :ref:`recolección <dgc_algo_collect>` y si no se puede encontrar
617 suficiente espacio luego de ella se intenta crear un nuevo *pool* de memoria
618 pidiendo memoria al *low level allocator* (el sistema operativo generalmente).
620 Para intentar buscar un bloque de memoria libre se realiza lo siguiente::
622 function find_block_with_size(block_size) is
623 block = free_lists[block_size].pop_first()
625 assign_page(block_size)
626 block = free_lists[block_size].pop_first()
629 Si no se puede obtener un bloque de la lista de libres correspondiente, se
630 busca asignar una página libre al tamaño de bloque deseado de forma de
631 *alimentar* la lista de libres con dicho tamaño::
633 function assign_page(block_size) is
636 if page.block_size is FREE
637 page.block_size = block_size
638 foreach block in page
639 free_lists[page.block_size].link(block)
641 Cuando todo ello falla, el último recurso consiste en pedir memoria al sistema
642 operativo, creando un nuevo *pool*::
644 funciones new_pool(number_of_pages = 1) is
645 pool = alloc(pool.sizeof)
648 pool.number_of_pages = number_of_pages
649 pool.pages = alloc(number_of_pages * PAGE_SIZE)
650 if pool.pages is null
656 Se recuerda que la función ``alloc()`` es un :ref:`servicio
657 <gc_intro_services>` provisto por el *low level allocator* y en la
658 implementación actual de D_ en general es el sistema operativo (aunque
659 opcionalmente puede utilizarse la biblioteca estándar de C, que a su vez
660 utiliza el sistema operativo).
662 Cualquier error en estas funciones es propagado y en última instancia, cuando
663 todo falla, la función ``new()`` termina lanzando una excepción indicando que
666 Si el tamaño de bloque necesario para cumplir con la asignación de memoria es
667 de una página, entonces se utiliza otro algoritmo para alocar un objeto
670 function new_big(size) is
671 number_of_pages = ceil(size / PAGE_SIZE)
672 pages = find_pages(number_of_pages)
675 pages = find_pages(number_of_pages)
678 pool = new_pool(number_of_pages)
681 pages = assign_pages(pool, number_of_pages)
682 pages[0].block_size = PAGE
683 foreach page in pages[1..end]
684 page.block_size = CONTINUATION
687 De forma similar a la asignación de objetos pequeños, se intenta encontrar una
688 serie de páginas contíguas, dentro de un mismo *pool*, suficientes para
689 almacenar el tamaño requerido y si esto falla, se realizan diferentes pasos
690 y se vuelve a intentar. Puede observarse que, a diferencia de la asignación de
691 objetos pequeños, si luego de la recolección no se pudo encontrar lugar
692 suficiente, se trata de minimizar el uso de memoria física utilizando la
693 siguiente función, que devuelve al *low level allocator* los *pools*
694 completamente libres::
696 function minimize() is
700 if page.block_size is not FREE
708 Volviendo a la función ``new_big()``, para hallar una serie de páginas
709 contíguas se utiliza el siguiente algoritmo::
711 function find_pages(number_of_pages) is
713 pages = assign_pages(pool, number_of_pages)
718 Como se dijo, las páginas deben estar contenidas en un mismo *pool* (para
719 tener la garantía de que sean contíguas), por lo tanto se busca *pool* por
720 *pool* dicha cantidad de páginas libres consecutivas a través del siguiente
723 function assign_pages(pool, number_of_pages) is
727 if page.block_size is FREE
732 pages_found = pages_found + 1
733 if pages_found is number_of_pages
734 return [first_page .. page]
740 Una vez más, cuando todo ello falla (incluso luego de una recolección), se
741 intenta alocar un nuevo *pool*, esta vez con una cantidad de páginas
742 suficientes como para almacenar el objeto grande y si esto falla el error se
743 propaga hasta la función ``new()`` que lanza una excepción.
748 Liberación de memoria
749 ^^^^^^^^^^^^^^^^^^^^^
750 La liberación de la memoria asignada puede hacerse explícitamente. Esto
751 saltéa el mecanismo de recolección, y es utilizado para dar soporte a menejo
752 explícito de memoria asignada en el *heap* del recolector. En general el
753 usuario no debe utilizar liberación explícita, pero puede ser útil en casos
756 function delete(pointer) is
757 [pool, page, block_start] = find_block(pointer)
762 if page.block_size is PAGE // objeto grande
763 free_big_object(pool, page)
764 else // objeto pequeño
765 free_lists[page.block_size].link(block)
767 Como se puede observar, si el objeto es pequeño se enlaza a la lista de libres
768 correspondiente y si es grande se liberan todas las páginas asociadas a éste,
769 de forma similar a la :ref:`fase de barrido <dgc_algo_sweep>`. A diferencia de
770 ésta, no se finaliza el objeto (es decir, no se llama a su destructor).
777 Al finalizar el programa, el recolector es finalizado también y lo que realiza
778 actualmente, además de liberar la memoria propia del recolector, es realizar
779 una recolección. Es decir, si hay objetos que son todavía alcanzables desde el
780 *root set*, esos objetos no son finalizados (y por lo tanto sus destructores
783 Como se ha visto, esto es perfectamente válido ya que D_ no garantiza que los
784 objetos sean finalizados.
790 Detalles de implementación
791 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
793 Hay varias diferencias a nivel de implementación entre lo que se presentó en
794 las secciones anteriores y como está implementado realmente el recolector
795 actual. Con los conceptos e ideas principales del ya explicadas, se procede
796 a ahondar con más detalle en como está construído el recolector y algunas de
797 sus optimizaciones principales.
799 Vale aclarar que el recolector de basura actual está implementado en D_.
802 Estructuras de datos del recolector
803 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
804 El recolector está principalmente contenido en la estructura llamada ``Gcx``.
805 Dicha estructura tiene los siguientes atributos (divididos en categorías para
806 facilitar la comprensión):
808 **Raíces definidas por el usuario**
810 *roots* (*nroots*, *rootdim*):
811 arreglo variable de punteros simples que son tomados como raíces
812 provistas por el usuario.
814 *ranges* (*nranges*, *rangedim*):
815 arreglo variable de rangos de memoria que deben ser revisados (de forma
816 conservativa) como raíces provistas por el usuario. Un rango es una
817 estructura con dos punteros: ``pbot`` y ``ptop``. Toda la memoria entre
818 estos dos punteros se toma, palabra por palabra, como una raíz del
821 **Estado interno del recolector**
824 variable que indica si en la fase de marcado se encontraron nuevas
825 celdas con punteros que deban ser visitados. Otra forma de verlo es como
826 un indicador de si el conjunto de celdas *grises* está vacío luego de
827 una iteración de marcado (utilizando la :ref:`abstracción tricolor
828 <gc_intro_tricolor>`). Es análoga a la variable ``more_to_scan``
829 presentada en :ref:`dgc_algo_mark`.
832 indica si el recolector fue inicializado.
835 puntero a la base del *stack* (asumiendo que el stack crece hacia arriba).
836 Se utiliza para saber por donde comenzar a visitar el *stack* de forma
837 conservativa, tomándolo con una raíz del recolector.
839 *Pools* (*pooltable*, *npools*):
840 arreglo variable de punteros a estructuras ``Pool`` (ver más adelante).
841 Este arreglo se mantiene siempre ordenado de menor a mayor según la
842 dirección de memoria de la primera página que almacena.
845 listas de libres. Es un arreglo de estructuras ``List`` utilizadas para
846 guardar la listas de libres de todos los tamaños de bloques posibles (ver
849 **Atributos que cambian el comportamiento**
852 indica que no debe tomarse al *stack* como raíz del recolector. Esto es
853 muy poco seguro y no debería ser utilizado nunca, salvo casos
854 extremadamente excepcionales.
857 indica si se debe guardar un registro de la actividad del recolector. Es
858 utilizado principalmente para depuración.
861 indica que no se deben realizar recolecciones implícitamente. Si al
862 tratar de asignar memoria no se puede hallar celdas libres en el *heap*
863 del recolector, se pide más memoria al sistema operativo sin correr una
864 recolección para intentar recuperar espacio. Esto es particularmente
865 útil para secciones de un programa donde la eficiencia es crítica y no
866 se pueden tolerar grandes pausas como las que puede provocar el
871 *p_cache*, *size_cache*:
872 obtener el tamaño de un bloque dado un puntero es una tarea costosa
873 y común. Para evitarla en casos donde se calcula de forma sucesiva el
874 tamaño del mismo bloque (como puede ocurrir al concatenar arreglos
875 dinámicos) se guarda el último calculado en estas variables a modo de
878 *minAddr*, *maxAddr*:
879 punteros al principio y fin del *heap*. Pueden haber *huecos* entre
880 estos dos punteros que no pertenezcan al *heap* pero siempre se cumple
881 que si un puntero apunta al *heap* debe estar en este rango. Esto es
882 útil para hacer un cálculo rápido para descartar punteros que fueron
883 tomados de forma conservativa y en realidad no apuntan al *heap* (ver la
884 función ``find_block()`` en :ref:`dgc_algo_mark`).
889 La primera diferencia es como está organizado el *heap*. Si bien la
890 explicación presentada en la sección :ref:`dgc_org` es correcta, la forma en
891 la que está implementado no es tan *naïve* como los algoritmos presentados en
892 :ref:`dgc_algo` sugieren.
894 El recolector guarda un arreglo variable de estructuras ``Pool``. Cabe
895 destacar que para implementar el recolector no se pueden utilizar los arreglos
896 dinámicos de D_ (ver sección :ref:`d_high_level`) dado que éstos utilizan de
897 forma implícita el recolector de basura, por lo tanto todos los arreglos
898 variables del recolector se implementan utilizando las funciones de
899 C ``malloc()``, ``realloc()`` y ``free()`` directamente.
902 La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura
903 :vref:`fig:dgc-pool`):
905 *baseAddr* y *topAddr*:
906 punteros al comienzo y fin de la memoria que almacena todas las páginas del
907 *pool* (*baseAddr* es análogo al atributo *pages* utilizado en las
908 secciones anteriores para mayor claridad).
910 *mark*, *scan*, *freebits*, *finals*, *noscan*:
911 conjunto de bits (*bitsets*) para almacenar los indicadores descriptos en
912 :ref:`dgc_org` para todos los bloques de todas las páginas del *pool*.
913 *freebits* es análogo a *free* y *finals* a *final* en los atributos
914 descriptos en las secciones anteriores.
917 cantidad de páginas que contiene este *pool* (fue nombrado
918 *number_of_pages* en las secciones anteriores para mayor claridad).
921 cantidad de páginas *encomendadas* al sistema operativo (*committed* en
922 inglés). Este atributo no se mencionó anteriormente porque el manejo de
923 páginas encomendadas le agrega una complejidad bastante notable al
924 recolector y es solo una optimización para un sistema operativo en
925 particular (Microsoft Windows).
928 arreglo de indicadores de tamaño de bloque de cada página de este *pool*.
929 Los indicadores válidos son ``B_16`` a ``B_2048`` (pasando por los valores
930 posibles de bloque mencionados anteriormente, todos con el prefijo
931 "``B_``"), ``B_PAGE``, ``B_PAGEPLUS`` (análogo a ``CONTINUATION``),
932 ``B_UNCOMMITTED`` (valor que tienen las páginas que no fueron encomendadas
935 .. fig:: fig:dgc-pool
937 Vista gráfica de la estructura de un *pool* de memoria.
943 /--- "baseAddr" "ncommitted = i" "topAddr" ---\
946 +---- "committed" -----+------- "no committed" ----------+
949 +--------+--------+-----+--------+-----+-------------------+
950 páginas | 0 | 0 | ... | i | ... | "npages - 1" |
951 +--------+--------+-----+--------+-----+-------------------+
954 +--------+--------+-----+--------+-----+-------------------+
955 pagetable | Bins 0 | Bins 1 | ... | Bins i | ... | "Bins (npages-1)" |
956 +--------+--------+-----+--------+-----+-------------------+
958 Como se observa, además de la información particular del *pool* se almacena
959 toda la información de páginas y bloques enteramente en el *pool* también.
960 Esto simplifica el manejo de que lo es memoria *pura* del *heap*, ya que queda
961 una gran porción contínua de memoria sin estar intercalada con
962 meta-información del recolector.
964 Para poder acceder a los bits de un bloque en particular, se utiliza la
965 siguiente cuenta para calcular el índice en el *bitset*:
969 index(p) = \frac{p - baseAddr}{16}
971 Donde ``p`` es la dirección de memoria del bloque. Esto significa que, sin
972 importar cual es el tamaño de bloque de las páginas del *pool*, el *pool*
973 siempre reserva suficientes bits como para que todas las páginas puedan tener
974 tamaño de bloque de 16 bytes. Esto puede ser desperdiciar bastante espacio si
975 no predomina un tamaño de bloque pequeño.
980 Las listas de libres se almacenan en el recolector como un arreglo de
981 estructuras ``Lista``, que se compone solamente de un atributo ``List* next``
982 (es decir, un puntero al siguiente). Entonces cada elemento de ese arreglo es
983 un puntero al primer elemento de la lista en particular.
985 La implementación utiliza a los bloques de memoria como nodos directamente.
986 Como los bloques siempre pueden almacenar una palabra (el bloque de menor
987 tamaño es de 16 bytes y una palabra ocupa comunmente entre 4 y 8 bytes según
988 se trabaje sobre arquitecturas de 32 o 64 bits respectivamente), se almacena
989 el puntero al siguiente en la primera palabra del bloque.
994 Los algoritmos en la implementación real están considerablemente menos
995 modularizados que los presentados en la sección :ref:`dgc_algo`. Por ejemplo,
996 la función ``collect()`` es una gran función de 300 líneas de código.
998 A continuación se resumen las funciones principales, separadas en categorías
999 para facilitar la comprensión. Los siguientes son métodos de la estructura
1002 **Inicialización y terminación**
1005 inicializa las estructuras internas del recolector para que pueda ser
1006 utilizado. Esta función la llama la biblioteca *runtime* antes de que el
1007 programa comience a correr.
1010 libera todas las estructuras que utiliza el recolector.
1012 **Manipulación de raíces definidas por el usuario**
1014 *addRoot(p)*, *removeRoot(p)*, *rootIter(dg)*:
1015 agrega, remueve e itera sobre las raíces simples definidas por el
1018 *addRange(pbot, ptop)*, *remove range(pbot)*, *rangeIter(dg)*:
1019 agrega, remueve e itera sobre los rangos de raíces definidas por el
1022 **Manipulación de indicadores**
1024 Cada bloque (*bin* en la terminología de la implementación del recolector)
1025 tiene ciertos indicadores asociados. Algunos de ellos pueden ser
1026 manipulados (indirectamente) por el usuario utilizando estas funciones:
1028 *getBits(pool, biti)*:
1029 obtiene los indicadores especificados para el bloque de índice ``biti``
1030 en el *pool* ``pool``.
1032 *setBits(pool, biti, mask)*:
1033 establece los indicadores especificados en ``mask`` para el bloque de
1034 índice ``biti`` en el *pool* ``pool``.
1036 *clrBits(pool, biti, mask)*:
1037 limpia los indicadores especificados en ``mask`` para el bloque de
1038 índice ``biti`` en el *pool* ``pool``.
1040 El parámetro ``mask`` debe ser una máscara de bits que puede estar
1041 compuesta por la conjunción de los siguientes valores:
1044 el objeto almacenado en el bloque tiene un destructor (indicador
1048 el objeto almacenado en el bloque no contiene punteros (indicador
1052 el objeto almacenado en el bloque no debe ser movido [#dgcmove]_.
1054 .. [#dgcmove] Si bien el recolector actual no tiene la capacidad de mover
1055 objetos, la interfaz del recolector hacer que sea posible una
1056 implementación que lo haga, ya que a través de este indicador se pueden
1057 fijar objetos apuntados desde algún segmento no conservativo (objeto
1063 busca el *pool* al que pertenece el objeto apuntado por ``p``.
1066 busca la dirección base (el inicio) del bloque apuntado por ``p``
1067 (``find_block()`` según la sección :ref:`dgc_algo_mark`).
1070 busca el tamaño del bloque apuntado por ``p``.
1073 obtiene información sobre el bloque apuntado por ``p``. Dicha
1074 información se retorna en una estructura ``BlkInfo`` que contiene los
1075 siguientes atributos: ``base`` (dirección del inicio del bloque),
1076 ``size`` (tamaño del bloque) y ``attr`` (atributos o indicadores del
1077 bloque, los que se pueden obtener con ``getBits()``).
1080 calcula el tamaño de bloque más pequeño que pueda contener un objeto de
1081 tamaño ``size`` (``find_block_size()`` según lo visto en
1082 :ref:`dgc_algo_alloc`).
1084 **Asignación de memoria**
1086 Recordar que la ``pooltable`` siempre se mantiene ordenada según la
1087 dirección de la primera página.
1090 reserva un nuevo *pool* de al menos ``size`` bytes. El algoritmo nunca
1091 crea un *pool* con menos de 256 páginas (es decir, 1 MiB).
1094 minimiza el uso de la memoria retornando *pools* sin páginas usadas al
1098 reserva un nuevo *pool* con al menos ``n`` páginas. Junto con
1099 ``Pool.initialize()`` es análoga a ``new_pool()``, solo que esta función
1100 siempre incrementa el número de páginas a, al menos, 256 páginas (es
1101 decir, los *pools* son siempre mayores a 1 MiB). Si la cantidad de
1102 páginas pedidas supera 256, se incrementa el número de páginas en un 50%
1103 como para que sirva para futuras asignaciones también. Además a medida
1104 que la cantidad de *pools* crece, también trata de obtener cada vez más
1105 memoria. Si ya había un *pool*, el 2do tendrá como mínimo 2 MiB, el 3ro
1106 3 MiB y así sucesivamente hasta 8 MiB. A partir de ahí siempre crea
1107 *pools* de 8 MiB o la cantidad pedida, si ésta es mayor.
1109 *Pool.initialize(n_pages)*:
1110 inicializa un nuevo *pool* de memoria. Junto con ``newPool()`` es
1111 análoga a ``new_pool()``. Mientras ``newPool()`` es la encargada de
1112 calcular la cantidad de páginas y crear el objeto *pool*, esta función
1113 es la que pide la memoria al sistema operativo. Además inicializa los
1114 conjuntos de bits: ``mark``, ``scan``, ``freebits``, ``noscan``.
1115 ``finals`` se inicializa de forma perezosa, cuando se intenta asignar el
1116 atributo ``FINALIZE`` a un bloque, se inicializa el conjunto de bits
1117 ``finals`` de todo el *pool*.
1120 asigna a una página libre el tamaño de bloque ``bin`` y enlaza los
1121 nuevos bloques libres a la lista de libres correspondiente (análogo
1122 a ``assign_page()``).
1125 Busca ``n`` cantidad de páginas consecutivas libres (análoga
1126 a ``find_pages(n)``).
1128 *malloc(size, bits)*:
1129 asigna memoria para un objeto de tamaño ``size`` bytes. Análoga al
1130 algoritmo ``new(size, attr)`` presentado, excepto que introduce además
1131 un caché para no recalcular el tamaño de bloque necesario si se realizan
1132 múltiples asignaciones consecutivas de objetos del mismo tamaño y que la
1133 asignación de objetos pequeños no está separada en una función aparte.
1136 asigna un objeto grande (análogo a ``new_big()``). La implementación es
1137 mucho más compleja que la presentada en ``new_big()``, pero la semántica
1138 es la misma. La única diferencia es que esta función aprovecha que
1139 ``fullcollectshell()`` / ``fullcollect()`` retornan la cantidad de
1140 páginas liberadas en la recolección por lo que puede optimizar levemente
1141 el caso en que no se liberaron suficientes páginas para asignar el
1142 objeto grande y pasar directamente a crear un nuevo *pool*.
1145 libera la memoria apuntada por ``p`` (análoga a ``delete()`` de la
1151 marca un rango de memoria. Este método es análogo al ``mark()``
1152 presentado en la sección :ref:`dgc_algo_mark` pero marca un rango
1153 completo de memoria, lo que permite que sea considerablemente más
1156 *fullcollectshell()*:
1157 guarda los registros en el *stack* y llama a ``fullcollect()``. El
1158 algoritmo presentado en :ref:`dgc_algo_mark` es simbólico, ya que si los
1159 registros se apilaran en el *stack* dentro de otra función, al salir de
1160 esta se volverían a desapilar, por lo tanto debe ser hecho en la misma
1161 función ``collect()`` o en una función que luego la llame (como en este
1164 *fullcollect(stackTop)*:
1165 realiza la recolección de basura. Es análoga a ``collect()`` pero
1166 considerablemente menos modularizada, todos los pasos se hacen
1167 directamente en esta función: marcado del *root set*, marcado iterativo
1168 del *heap*, barrido y reconstrucción de la lista de libres. Además
1169 devuelve la cantidad de páginas que se liberaron en la recolección, lo
1170 que permite optimizar levemente la función ``bigAlloc()``.
1175 El recolector actual, por omisión, solamente efectúa una recolección al
1176 finalizar. Por lo tanto, no se ejecutan los destructores de todos aquellos
1177 objetos que son alcanzables desde el *root set* en ese momento. Existe la
1178 opción de no realizar una recolección al finalizar el recolector, pero no de
1179 finalizar *todos* los objetos (alcanzables o no desde el *root set*). Si bien
1180 la especificación de D_ permite este comportamiento (de hecho la
1181 especificación de D_ es tan vaga que permite un recolector que no llame jamás
1182 a ningún destructor), para el usuario puede ser una garantía muy débil
1183 y proveer finalización asegurada puede ser muy deseable.
1186 Memoria *encomendada*
1187 ^^^^^^^^^^^^^^^^^^^^^
1188 El algoritmo actual divide un *pool* en dos áreas: memoria *encomendada*
1189 (*committed* en inglés) y *no-encomentada*. Esto se debe a que originalmente
1190 el compilador de D_ DMD_ solo funcionaba en Microsoft Windows y este sistema
1191 operativo puede asignar memoria en dos niveles. Por un lado puede asignar al
1192 proceso un espacio de memoria (*address space*) pero sin asignarle la memoria
1193 correspondiente. En un paso posterior se puede *encomendar* la memoria (es
1194 decir, asignar realmente la memoria).
1196 Para aprovechar esta característica el recolector diferencia estos dos
1197 niveles. Sin embargo, esta diferenciación introduce una gran complejidad (que
1198 se omitió en las secciones anteriores para facilitar la comprensión),
1199 y convierte lo que es una ventaja en un sistema operativo en una desventaja
1200 para todos los demás (ya que los cálculos extra se realizan pero sin ningún
1201 sentido). De hecho hay sistemas operativos, como Linux_, que realizan este
1202 trabajo automáticamente (la memoria no es asignada realmente al programa hasta
1203 que el programa no haga uso de ella; esta capacidad se denomina *overcommit*).
1205 Como se vio en la figura :vref:`fig:dgc-pool`, lás páginas de un *pool* se
1206 dividen en *committed* y *uncommitted*. Siempre que el recolector recorre un
1207 *pool* en busca de una página o bloque, lo hace hasta la memoria *committed*,
1208 porque la *uncommitted* es como si jamás se hubiera pedido al sistema
1209 operativo a efectos prácticos. Además, al buscar páginas libres, si no se
1210 encuentran entre las *encomendadas* se intenta primero *encomendar* páginas
1211 nuevas antes de crear un nuevo *pool*.
1216 Si bien el recolector no es paralelo ni concurrente (ver :ref:`gc_art`),
1217 soporta múltiples *mutator*\ s. La forma de implementarlo es la más simple.
1218 Todas las operaciones sobre el recolector que se llaman externamente están
1219 sincronizadas utilizando un *lock* global (excepto cuando hay un solo hilo
1220 *mutator*, en cuyo caso se omite la sincronización). Esto afecta también a la
1221 asignación de memoria.
1227 Problemas y limitaciones
1228 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1230 A continuación se presentan los principales problemas encontrados en la
1231 implementación actual del recolector de basura de D_. Estos problemas surgen
1232 principalmente de la observación del código y de aproximadamente 3 años de
1233 participación y observación del grupo de noticias, de donde se obtuvieron los
1234 principales problemas percibidos por la comunidad que utiliza el lenguaje.
1237 Complejidad del código y documentación
1238 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1239 El análisis del código fue muy complicado debido a la falta de documentación
1240 y desorganización del código. Además se nota que el recolector ha sido escrito
1241 en una fase muy temprana y que a ido evolucionando a partir de ello de forma
1242 desprolija y sin ser rescrito nunca para aprovechar las nuevas características
1243 que el lenguaje fue incorporando (por ejemplo *templates*).
1245 Estos dos problemas (código complicado y falta de documentación) producen un
1246 efecto de círculo vicioso, porque provocan que sea complejo entender el
1247 recolector actual y en consecuencia sea muy complicado escribir documentación
1248 o mejorarlo. Esto a su vez provoca que, al no disponer de una implementación
1249 de referencia sencilla, sea muy difícil implementar un recolector nuevo.
1251 Este es, probablemente, la raíz de todos los demás problemas del recolector
1252 actual. Para ilustrar la dimensión del problema se presenta la implementación
1253 real de la función ``bigAlloc()``::
1256 * Allocate a chunk of memory that is larger than a page.
1257 * Return null if out of memory.
1259 void *bigAlloc(size_t size)
1269 npages = (size + PAGESIZE - 1) / PAGESIZE;
1273 // This code could use some refinement when repeatedly
1274 // allocating very large arrays.
1276 for (n = 0; n < npools; n++)
1278 pool = pooltable[n];
1279 pn = pool.allocPages(npages);
1293 freedpages = fullcollectshell();
1294 if (freedpages >= npools * ((POOLSIZE / PAGESIZE) / 4))
1298 // Release empty pools to prevent bloat
1300 // Allocate new pool
1301 pool = newPool(npages);
1306 pn = pool.allocPages(npages);
1307 assert(pn != OPFAIL);
1310 // Release empty pools to prevent bloat
1312 // Allocate new pool
1313 pool = newPool(npages);
1316 pn = pool.allocPages(npages);
1317 assert(pn != OPFAIL);
1327 pool.pagetable[pn] = B_PAGE;
1329 cstring.memset(&pool.pagetable[pn + 1], B_PAGEPLUS, npages - 1);
1330 p = pool.baseAddr + pn * PAGESIZE;
1331 cstring.memset(cast(char *)p + size, 0, npages * PAGESIZE - size);
1332 debug (MEMSTOMP) cstring.memset(p, 0xF1, size);
1333 //debug(PRINTF) printf("\tp = %x\n", p);
1337 return null; // let mallocNoSync handle the error
1340 Se recuerda que la semántica de dicha función es la misma que la de la función
1341 ``new_big()`` presentada en :ref:`dgc_algo_alloc`.
1343 Además, como se comentó en la sección anterior, los algoritmos en la
1344 implementación real están considerablemente menos modularizados que los
1345 presentados en la sección :ref:`dgc_algo`. Por ejemplo, la función
1346 ``fullcollect()`` son 300 líneas de código.
1349 Memoria *encomendada*
1350 ^^^^^^^^^^^^^^^^^^^^^
1351 Como se comentó en la sección anterior, diferenciar entre memoria
1352 *encomendada* de memoria *no-encomendada* es complejo y levemente costoso (en
1353 particular para sistemas operativos que no hacen esta distinción, al menos
1354 explícitamente, donde no hay ningún beneficio en realizar esta distinción).
1356 Incluso para Microsoft Windows, la ventaja de realizar esta distinción es
1362 Este fue historicamente uno de los problemas principales del recolector de D_
1363 [NGD46407]_ [NGD35364]_. Sin embargo, desde que, en la versión 1.001, se ha
1364 incorporado la capacidad de marcar un bloque como de datos puros (no contiene
1365 punteros, el atributo ``NO_SCAN``) [NGA6842]_, la gravedad de esos problemas ha
1366 disminuído considerablemente, aunque siguieron reportándose problemas más
1367 esporádicamente [NGD54084]_ [NGL13744]_.
1369 De todas maneras queda mucho lugar para mejoras, y es un tema recurrente en el
1370 grupo de noticias de D_ y se han discutido formas de poder hacer que, al menos
1371 el *heap* sea preciso [NGD44607]_ [NGD29291]_. Además se mostro un interés
1372 general por tener un recolector más preciso [NGDN87831]_, pero no han habido
1373 avances al respecto.
1375 Otra forma de minimizar los efectos de la falta de precisión que se ha
1376 sugerido reiteradamente en el grupo es teniendo la
1377 posibilidad de indicar cuando no pueden haber punteros interiores a un bloque
1378 [NGD89394]_ [NGD71869]_. Esto puede ser de gran utilidad para objetos grandes
1379 y en particular para mejorar la implementación de de arreglos asociativos.
1384 El recolector actual no dispone de soporte de *referencias débiles*
1385 [#dgcweakref]_, sin embargo hay una demanda [NGD86840]_ [NGD13301]_ [NGL8264]_
1386 [NGD69761]_ [NGD74624]_ [NGD88065]_
1388 .. [#dgcweakref] Una referencia débil (o *weak reference* en inglés) es
1389 aquella que que no protege al objeto referenciado de ser reciclado por el
1392 Para cubrir esta demanda, se han implementado soluciones como biblioteca para
1393 suplir la inexistencia de una implementación oficial [NGA9103]_.
1395 Sin embargo éstas son en general poco robustas y extremadamente dependientes
1396 de la implementación del recolector y, en general, presentan problemas muy
1397 sutiles [NGD88065]_. Por esta razón se ha discutido la posibilidad de incluir
1398 la implementación de *referencias débiles* como parte del lenguaje
1404 El soporte actual de concurrencia, en todos sus aspectos, es muy primitivo. El
1405 recolector apenas soporta múltiples *mutators* pero con un nivel de
1406 sincronización excesivo.
1408 Se ha sugerido en el pasado el uso de *pools* y listas de libres específicos
1409 de hilos, de manera de disminuir la contención, al menos para la asignación de
1410 memoria [NGD75952]_ [NGDN87831]_.
1412 Además se ha mostrado un interés por tener un nivel de concurrencia aún mayor
1413 en el recolector, para aumentar la concurrencia en ambientes *multi-core* en
1414 general pero en particular para evitar grandes pausas en programas con
1415 requerimientos de tiempo real, historicamente una de las principales críticas
1416 al lenguaje [NGDN87831]_ [NGL3937]_ [NGD22968]_ [NGA15246]_ [NGD5622]_
1417 [NGD2547]_ [NGD18354]_.
1422 El recolector actual no garantiza la finalización de objetos. En particular
1423 los objetos no son finalizados (es decir, no se llama a sus destructores)
1424 si aún alcanzables desde el *root set* cuando el programa termina. Cabe
1425 destacar que esto puede darse porque hay una referencia real desde el *root
1426 set* (en cuyo caso queda bajo el control del usuario) pero también, dado que
1427 el *root set* se visita de forma conservativa, se puede deber a un falso
1428 positivo, en cuyo caso la omisión de la finalización queda por completo fuera
1429 del control del usuario (y lo que es aún peor, el usuario no puede ser
1430 siquiera notificado de esta anomalía).
1432 Si bien la especificación de D_ no requiere esta capacidad (de hecho,
1433 rigurosamente hablando la especificación de D_ no garantiza la finalización de
1434 objetos bajo ninguna circunstancia), no hay mayores problemas para implementar
1435 un recolector que de este tipo de garantías [NGD88298]_.
1437 Además los objetos pueden ser finalizados tanto determinísticamente
1438 (utilizando ``delete`` o ``scope``; ver secciones :ref:`d_low_level`
1439 y :ref:`d_dbc`) como no deterministicamente (cuando son finalizados por el
1440 recolector). En el primer caso se puede, por ejemplo, acceder sus atributos
1441 u otra memoria que se conozca *viva*, mientras que en el segundo no. Sin
1442 embargo un destructor no puede hacer uso de esta distinción, haciendo que la
1443 finalización determinística tenga a fines prácticos las mismas restricciones
1444 que la finalización no deterministica. Es por esto que se ha sugerido permitir
1445 al destructor distinguir estos dos tipos de finalización [NGD89302]_.
1450 La eficiencia en general del recolector es una de las críticas frecuentes. Si
1451 bien hay muchos problemas que han sido resueltos, en especial por la inclusión
1452 de un mínimo grado de precisión en la versión 1.001, en la actualidad se
1453 siguen encontrando en el grupo de noticias críticas respecto a esto
1454 [NGD43991]_ [NGD67673]_ [NGD63541]_ [NGD90977]_.
1456 La principal causa de la ineficiencia del recolector actual es, probablemente,
1457 lo simple de su algoritmo principal de recolección. Más allá de una
1458 organización del *heap* moderadamente apropiada y de utilizar conjuntos de
1459 bits para la fase de marcado, el resto del algoritmo es casi la versión más
1460 básica de marcado y barrido. Hay mucho lugar para mejoras en este sentido.
1465 Finalmente hay varios detalles en la implementación actual que podrían
1469 hay 12 listas de libres, como para guardar bloques de tamaño de ``B_16``
1470 a ``B_2048``, ``B_PAGE``, ``B_PAGEPLUS``, ``B_UNCOMMITTED`` y ``B_FREE``;
1471 sin embargo solo tienen sentido los bloques de tamaño ``B_16`` a ``B_2048``,
1472 por lo que 4 de esas listas no se utilizan.
1475 los indicadores para la fase de marcado y otras propiedades de un bloque son
1476 almacenados en conjuntos de bits que almacenan los indicadores de todos los
1477 bloques de un *pool*. Como un *pool* tiene páginas con distintos tamaños de
1478 bloque, se reserva una cantidad de bits igual a la mayor cantidad posible de
1479 bloques que puede haber en el *pool*; es decir, se reserva 1 bit por cada 16
1480 bytes del *pool*. Para un *pool* de 1 MiB (tamaño mínimo), teniendo en
1481 cuenta que se utilizan 5 conjuntos de bits (``mark``, ``scan``, ``finals``,
1482 ``freebits`` y ``noscan``), se utilizan 40 KiB de memoria para conjuntos de
1483 bits (un 4% de *desperdicio* si, por ejemplo, ese *pool* estuviera destinado
1484 por completo a albergar un solo objeto grande; lo que equivaldría al 2560
1485 objetos de 16 bytes desperdiciados en bits inutilizados).
1487 Repetición de código:
1488 Hay algunos fragmentos de código repetidos inecesariamente. Por ejemplo en
1489 varios lugares se utilizan arreglos de tamaño variable que se implementan
1490 repetidas veces (en general como un puntero al inicio del arreglo más el
1491 tamaño actual del arreglo más el tamaño de la memoria total asignada
1492 actualmente). Esto es propenso a errores y difícil de mantener.
1495 el recolector actual utiliza las señales del sistema operativo ``SIGUSR1``
1496 y ``SIGUSR2`` para pausar y reanudar los hilos respectivamente. Esto
1497 puede traer incovenientes a usuarios que desean utilizar estas
1498 señales en sus programas (o peor aún, si interactúan con bibliotecas
1499 de C que hacen uso de estas señales) [NGD5821]_.
1502 .. include:: links.rst
1504 .. vim: set ts=3 sts=3 sw=3 et tw=78 :
projects / z.facultad / 75.00 / informe.git / blob