4 Recolección de basura en D
5 ============================================================================
7 D_ propone un nuevo desafío en cuanto al diseño de un recolector de basura,
8 debido a la gran cantidad de características que tiene y paradigmas que
11 D_ ya cuenta con un recolector que hace lo necesario para funcionar de forma
12 aceptable, pero su diseño e implementación son relativamente sencillos
13 comparados con el :ref:`estado del arte <gc_art>` de la recolección de basura
14 en general. Además la implementación actual presenta una serie de problemas
15 que se evidencia en las quejas que regularmente la comunidad de usuarios de D_
16 menciona en el grupo de noticias.
18 En esta sección se analizarán las necesidades particulares de D_ con respecto
19 a la recolección de basura. También se analiza el diseño e implementación del
20 recolector actual, presentando sus fortalezas y debilidades. Finalmente se
21 analiza la viabilidad de los diferentes algoritmos vistos en :ref:`gc_art`.
27 Características y necesidades particulares de D_
28 ----------------------------------------------------------------------------
30 En esta sección se hará un recorrido por las características y necesidades
31 particulares que tiene D_ como lenguaje con respecto a la recolección de
36 .. _dgc_prob_low_level:
38 Programación de bajo nivel (*system programming*)
39 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
41 Sin dudas las características de D_ que lo hacen más complejo a la hora de
42 implementar un recolector de basura son sus capacidades de programación de
43 bajo nivel (ver :ref:`d_low_level`).
45 Al proveer acceso a *assembly*, permitir estructuras de tipo *union* y ser
46 compatible con C/C++, el recolector de basura tiene muchas restricciones. Por
47 ejemplo debe tratar de forma conservativa los registros y el *stack*, ya que
48 es la única forma de interactuar de forma segura con C/C++ y *assembly*.
50 Además debe poder interactuar con manejo de memoria explícito, ya sea
51 omitiendo por completo el *heap* del recolector o liberando explícitamente
52 memoria de éste. Esta característica es muy inusual en un recolector,
53 a excepción de recolectores conservativos diseñados para C/C++ que tienen las
54 mismas (o más) limitaciones.
56 La posibilidad de controlar la alineación de memoria es otra complicación
57 sobre el recolector de basura, incluso aunque éste sea conservativo. Dado que
58 tratar la memoria de forma conservativa byte a byte sería impracticable (tanto
59 por la cantidad de *falsos positivos* que esto provocaría como por el impacto
60 en el rendimiento por el exceso de posibles punteros a revisar, además de lo
61 ineficiente que es operar sobre memoria no alineada), en general el recolector
62 asume que el usuario nunca va a tener la única referencia a un objeto en una
63 estructura no alineada al tamaño de palabra.
67 .. _d_prob_high_level:
69 Programación de alto nivel
70 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
72 Las características de programación de alto nivel también impone dificultades
73 o restricciones al recolector de basura (ver :ref:`d_high_level`). Por ejemplo
74 el soporte de rebanado (*slicing*) de arreglos hace que el recolector deba
75 soportar punteros *interiores* [#dgcinterior]_ (esto también es necesario
76 porque en general en D_ o en cualquier lenguaje de bajo nivel se puede tener
77 un puntero a cualquier parte de una celda).
79 .. [#dgcinterior] Los punteros *interiores* son aquellos que en vez de apuntar
80 al inicio de una celda, apuntan a una dirección arbitraria dentro de ella.
81 Esto no es posible en muchos lenguajes de programación, como por ejemplo
82 Java_, lo que simplifica la recolección de basura.
84 Los arreglos dinámicos y asociativos en particular dependen fuertemente del
85 recolector de basura, en particular cuando se agregan elementos (o se
86 concatenan dos arreglos).
88 Dado que los *strings* son arreglos dinámicos y que el lenguaje provee un buen
89 soporte de arreglos dinámicos y asociativos y *slicing*, es de esperarse que
90 el recolector deba comportarse de forma correcta y eficiente ante las
91 operaciones más típicas de estas estructuras que dependan de él.
98 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
100 Hasta aquí D_ comparte todas las restricciones con respecto a la recolección
101 de basura con los lenguajes de bajo nivel que no tienen ningún soporte para
102 recolectar basura. Sin embargo, a diferencia de éstos, D_ tiene una
103 información de tipos más rica. Al momento de asignar memoria D_ puede proveer
104 cierta información sobre el objeto a asignar (como si puede contener punteros
105 o no) que puede ser utilizada por el recolector para realizar una recolección
106 más precisa (ver :ref:`gc_conserv`).
108 En general esta información no es suficiente como para implementar un
109 recolector completamente preciso (no al menos sin agregar un mejor soporte de
110 reflexión al lenguaje) pero puede ser de ayuda considerable para el
117 Orientación a objetos y finalización
118 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
120 D_ soporta el paradigma de orientación a objetos, donde es común permitir que
121 un objeto, al ser destruido, realice alguna tarea de finalización (a través de
122 una función miembro llamada *destructor*, o ``~this()`` en D_). Esto significa
123 que el recolector, al encontrar que no hay más referencias a un objeto, debe
124 ejecutar el destructor.
126 La especificación dice [DWDE]_:
128 The garbage collector is not guaranteed to run the destructor for all
129 unreferenced objects. Furthermore, the order in which the garbage collector
130 calls destructors for unreference objects is not specified. This means that
131 when the garbage collector calls a destructor for an object of a class that
132 has members that are references to garbage collected objects, those
133 references may no longer be valid. This means that destructors cannot
134 reference sub objects.
136 Afortunadamente el orden de finalización no está definido, ya que esto sería
137 extremadamente difícil de proveer por un recolector (si no imposible). Esto
138 significa que si bien se ejecutan los destructores de los objetos que dejan de
139 ser alcanzables desde el *root set*, no se define en que orden se hace, y por
140 lo tanto un objeto no puede acceder a sus atributos que sean referencias
141 a otros objetos en un destructor.
143 Esta restricción en realidad se ve relaja con el soporte de *RAII*. Si se
144 utiliza la palabra clave ``scope`` al crear una serie de objetos, estos serán
145 destruidos determinísticamente al finalizar el *scope* actual en el orden
146 inverso al que fueron creados y, por lo tanto, un usuario podría hacer uso de
147 los atributos que sean referencias a otros objetos creados con ``scope`` si el
148 orden en que fueron creados (y por lo tanto en que serán destruidos) se lo
151 Sin embargo no hay forma actualmente de saber dentro de un destructor si éste
152 fue llamado determinísticamente o no, por lo tanto es virtualmente imposible
153 hacer uso de esta distinción, a menos que una clase sea declarada para ser
154 creada solamente utilizando la palabra reservada ``scope``.
156 Cabe aclarar que, estrictamente hablando y según la especificación de D_, el
157 recolector no debe garantizar la finalización de objetos bajo ninguna
158 circunstancia, es decir, el recolector podría no llamar a ningún destructor.
159 Sin embargo esto es probablemente una vaguedad en la redacción y dadas las
160 garantías que provee la implementación actual la comunidad de D_ cuenta con
167 Recolector de basura actual de D
168 ----------------------------------------------------------------------------
170 Como paso básico fundamental para poder mejorar el recolector de basura de D_,
171 primero hay que entender la implementación actual, de forma de conocer sus
172 puntos fuertes, problemas y limitaciones.
174 Como se mencionó en la sección :ref:`d_lang`, hay dos bibliotecas base para
175 soportar el lenguaje (*runtimes*): Phobos_ y Tango_. La primera es la
176 biblioteca estándar de D_, la segunda un proyecto más abierto y dinámico que
177 surgió como alternativa a Phobos_ dado que estaba muy descuidada y que era muy
178 difícil impulsar cambios en ella. Ahora Phobos_ tiene el agravante de estar
179 *congelada* en su versión 1 (solo se realizan correcciones de errores).
181 Dado que Tango_ está mejor organizada, su desarrollo es más abierto (aceptan
182 cambios y mejoras) y que hay una mayor disponibilidad de programas
183 y bibliotecas escritos para Tango_, en este trabajo se decide tomar esta
184 biblioteca *runtime* como base para el análisis y mejoras propuestas, a pesar
185 de ser Phobos_ la estándar. De todas formas el recolector de basura de Tango_
186 es prácticamente el mismo que el de Phobos_, por lo tanto éste análisis en
187 particular es válido para cualquiera de las dos.
189 El recolector actual es un recolector :ref:`indirecto <gc_direct>`, :ref:`no
190 incremental <gc_inc>` que realiza un :ref:`marcado y barrido <gc_mark_sweep>`
191 relativamente básico. A diferencia del algoritmo clásico presentado éste
192 realiza un marcado no recursivo. La fase de marcado es :ref:`stop-the-world
193 <gc_concurrent` mientras que la fase de barrido corre en paralelo con el
194 *mutator*, excepto el hilo que disparó la recolección que es quien efectúa el
195 barrido (además los hilos que intenten asignar nueva memoria o interactuar con
196 el recolector de cualquier otra forma se bloquean hasta que la fase de barrido
197 concluya). El marcado es casi totalmente :ref:`conservativo <gc_conserv>`; si
198 bien posee alguna información de tipos (distingue entre celdas que pueden
199 tener punteros y celdas que definitivamente no los tienen, pero no dispone de
200 información sobre qué campos de las celdas son punteros y cuales no). Además
201 no tiene soporte alguno de :ref:`recolección particionada <gc_part>`.
203 Si bien el recolector es bastante básico, posee una :ref:`organización de
204 memoria <dgc_org>` relativamente moderna (utiliza una :ref:`lista de libres
205 <gc_free_list>` con un *two level allocator*) y algunas optimizaciones
206 particulares para amortiguar casos patológicos.
211 Organización del *heap*
212 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
214 La memoria del *heap* está organizada en *pools*. Un *pool* es una región de
215 *páginas* contiguas. Una página es, en general, la unidad mínima de memoria que
216 maneja un sistema operativo con soporte de memoria virtual. Cada página dentro
217 de un *pool* sirve a su vez como contenedora de bloques (llamados *bin* en la
218 :ref:`implementación <dgc_impl>`) de tamaño fijo. Todos los bloques
219 pertenecientes a la misma página tienen el mismo tamaño de bloque (ver figura
220 :vref:`fig:dgc-org`). Los tamaños de bloque posibles son potencias de 2 desde
221 16 bytes hasta 4096 (el tamaño típico de una página), es decir: 16, 32, 64,
222 128, 256, 512, 1024, 2048 y 4096 [#dgcpageplus]_. Todos los objetos, arreglos
223 o celdas en general se ubican en estos bloques (en uno del tamaño más pequeño
224 que haya que sea suficientemente grande como para almacenar dicho objeto). En
225 caso de que un objeto sea mayor a una página, se utilizan la menor cantidad de
226 páginas contiguas de un pool que tengan espacio suficiente para almacenar
229 .. [#dgcpageplus] Además existe otro tamaño de bloque especial que se utiliza
230 para indicar la continuación de un objeto grande (que ocupan más de una
235 Organización del *heap* del recolector de basura actual de D
237 Organización del *heap*. En este ejemplo todos los *pools* tienen 2 páginas
238 excepto el *pool* 2 que tiene una sola. El tamaño de bloque que almacena
239 cada página varía entre 64 bytes (página 0 del *pool* 2) hasta 4096 (ambas
240 páginas del *pool* N) que es una página completa.
245 +----------------------------------------------------------------------+
247 +======================================================================+
248 | "Pool 0" "Pool 1" "Pool 2" "Pool 3" ... "Pool N" |
249 | +----------+ +----------+ +----------+ +----------+ +----------+ |
250 | | Página 0 | | Página 0 | | Página 0 | | Página 0 | ... | Página 0 | |
251 | | (8x512) | | (4x1024) | | (64x64) | | (2x2048) | ... | (1x4096) | |
252 | |+--------+| |+--------+| |+--------+| |+--------+| |+--------+| |
253 | || Bloque || || || ||qqqqqqqq|| || || || || |
254 | |+--------+| || Bloque || ||qqqqqqqq|| || || || || |
255 | || Bloque || || || ||qqqqqqqq|| || || || || |
256 | |+--------+| |+--------+| ||qqqqqqqq|| || Bloque || || || |
257 | || Bloque || || || ||qqqqqqqq|| || || || || |
258 | |+--------+| || Bloque || ||qqqqqqqq|| || || || || |
259 | || Bloque || || || ||qqqqqqqq|| || || || || |
260 | |+--------+| |+--------+| ||qqqqqqqq|| |+--------+| || Bloque || |
261 | || Bloque || || || ||qqqqqqqq|| || || || || |
262 | |+--------+| || Bloque || ||qqqqqqqq|| || || || || |
263 | || Bloque || || || ||qqqqqqqq|| || || || || |
264 | |+--------+| |+--------+| ||qqqqqqqq|| || Bloque || || || |
265 | || Bloque || || || ||qqqqqqqq|| || || || || |
266 | |+--------+| || Bloque || ||qqqqqqqq|| || || || || |
267 | || Bloque || || || ||qqqqqqqq|| || || || || |
268 | |+--------+| |+--------+| |+--------+| |+--------+| |+--------+| |
269 | | Página 1 | | Página 1 | +----------+ | Página 1 | ... | Página 1 | |
270 | | (16x256) | | (8x512) | | (32x128) | ... | (1x4096) | |
271 | |+--------+| |+--------+| |+--------+| |+--------+| |
272 | |+--------+| || Bloque || ||nnnnnnnn|| || || |
273 | |+--------+| |+--------+| ||nnnnnnnn|| || || |
274 | |+--------+| || Bloque || ||nnnnnnnn|| || || |
275 | |+--------+| |+--------+| ||nnnnnnnn|| || || |
276 | |+--------+| || Bloque || ||nnnnnnnn|| || || |
277 | |+--------+| |+--------+| ||nnnnnnnn|| || || |
278 | |+--------+| || Bloque || ||nnnnnnnn|| || || |
279 | |+--------+| |+--------+| ||nnnnnnnn|| || Bloque || |
280 | |+--------+| || Bloque || ||nnnnnnnn|| || || |
281 | |+--------+| |+--------+| ||nnnnnnnn|| || || |
282 | |+--------+| || Bloque || ||nnnnnnnn|| || || |
283 | |+--------+| |+--------+| ||nnnnnnnn|| || || |
284 | |+--------+| || Bloque || ||nnnnnnnn|| || || |
285 | |+--------+| |+--------+| ||nnnnnnnn|| || || |
286 | |+--------+| || Bloque || ||nnnnnnnn|| || || |
287 | |+--------+| |+--------+| |+--------+| ... |+--------+| |
288 | +----------+ +----------+ +----------+ +----------+ |
289 +----------------------------------------------------------------------+
291 Cada página de un *pool* puede tener asignado un tamaño de bloque específico
292 o puede estar libre. A su vez, cada bloque puede estar ocupado por una celda
293 o estar libre. Los bloques libres de un tamaño específico (a excepción de
294 aquellos bloques que ocupen una página entera) además forman parte de una
295 :ref:`lista de libres <gc_free_list>` (ver figura :vref:`fig:dgc-free-list`).
296 Esto permite asignar objetos relativamente pequeños de forma bastante
299 .. flt:: fig:dgc-free-list
301 Ejemplo de listas de libres
303 .. digraph:: dgc_free_list
309 node [ shape = record, width = 0, height = 0 ];
311 subgraph cluster_heap {
315 free [ label = "Libres|<p16> 16|<p32> 32|<p64> 64|<p128> 128|<p256> 256|<p512> 512|<p1024> 1024|<p2048> 2048" ];
317 free:p16 -> b1 -> b2 -> b3;
318 free:p32 -> b4 -> b5 -> b6 -> b7 -> b8;
321 free:p256 -> b10 -> b11;
323 free:p1024 -> b13 -> b14;
324 free:p2048 -> b15 -> b16 -> b17;
330 Cada *pool* tiene la siguiente información asociada:
333 Cantidad de páginas que tiene. Esta cantidad es fija en toda la vida de un
337 Bloque de memoria contiguo de tamaño ``PAGE_SIZE * number_of_pages``
338 (siendo ``PAGE_SIZE`` el tamaño de página, que normalmente son 4096 bytes).
343 Cada página dentro de un *pool* tiene un único atributo asociado: *block_size*.
344 Se trata del tamaño de los bloques que almacena esta página.
346 Una página siempre almacena bloques del mismo tamaño, que pueden ser 16, 32,
347 64, 128, 256, 512, 1024, 2048 o 4096 (llamado con el nombre especial
348 ``PAGE``). Además hay dos tamaños de bloque simbólicos que tienen un
349 significado especial:
352 Indica que la página está completamente libre y disponible para albergar
353 cualquier tamaño de bloque que sea necesario (pero una vez que se le asignó
354 un nuevo tamaño de bloque ya no puede ser cambiado hasta que la página
355 vuelva a liberarse por completo).
358 Indica que esta página es la continuación de un objeto grande (es decir,
359 que ocupa dos o más páginas). Luego se presentan más detalles sobre objetos
362 Las páginas con estos tamaños de bloque especiales conceptualmente no
368 Cada bloque tiene asociados varios atributos:
371 Utilizado en la fase de :ref:`marcado <dgc_algo_mark>`, indica que un nodo
372 ya fue visitado (serían las celdas *negras* en la :ref:`abstracción
373 tricolor <gc_intro_tricolor>`).
376 Utilizado también en la fase de :ref:`marcado <dgc_algo_mark>`, indica que
377 una celda visitada todavía tiene *hijas* sin marcar (serían las celdas
378 *grises* en la :ref:`abstracción tricolor <gc_intro_tricolor>`).
381 Indica que el bloque está libre (no está siendo utilizado por ningún objeto
382 *vivo*). Esto es necesario solo por la forma en la que realiza el
383 :ref:`marcado <dgc_algo_mark>` y :ref:`barrido <dgc_algo_sweep>` en el
384 :ref:`algoritmo actual <dgc_algo>` (las celdas con este atributo son
385 tomadas como *basura* aunque estén marcadas con *mark*).
388 Indica que el bloque contiene un objeto que tiene un destructor (que debe
389 ser llamado cuando la celda pasa de *viva* a *basura*).
392 Indica que el bloque contiene un objeto que no tiene punteros y por lo
393 tanto no debe ser escaneado (no tiene *hijas*).
398 El recolector de basura actual de D_ trata de forma diferente a los objetos
399 grandes. Todo objeto grande empieza en un bloque con tamaño ``PAGE``
400 y (opcionalmente) continúa en los bloques contiguos subsiguientes que tengan
401 el tamaño de bloque ``CONTINUATION`` (si el objeto ocupa más que una página).
402 El fin de un objeto grande queda marcado por el fin del *pool* o una página
403 con tamaño de bloque distinto a ``CONTINUATION`` (lo que suceda primero).
405 Cuando un objeto grande se convierte en *basura*, todas sus páginas se liberan
406 por completo, siendo marcadas con tamaño ``FREE`` para que puedan ser
407 almacenado en ellas otros objetos grandes o incluso nuevos bloques de un
414 Algoritmos del recolector
415 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
417 A continuación se explica como provee el recolector actual de D_ los servicios
418 básicos que debe proveer cualquier recolector, como se presentó en la sección
419 :ref:`gc_intro_services`.
421 Cabe aclarar que se presenta una versión simplificada del algoritmo, o más
422 precisamente, de la implementación del algoritmo, ya que no se exponen en esta
423 sección muchas optimizaciones que harían muy compleja la tarea de explicar
424 como funciona conceptualmente. En la siguiente sección, :ref:`dgc_impl`, se
425 darán más detalles sobre las optimizaciones importantes y diferencias con el
426 algoritmo aquí presentado, junto con detalles sobre como se implementa la
427 organización del *heap* que se explicó en la sección anterior.
430 .. _dgc_algo_collect:
434 A grandes rasgos el algoritmo de recolección puede resumirse de las dos fases
435 básicas de cualquier algoritmo de :ref:`marcado y barrido <gc_mark_sweep>`::
437 function collect() is
446 Esta fase consiste de varios pasos, que pueden describirse con el siguiente
449 function mark_phase() is
450 global more_to_scan = false
452 clear_mark_scan_bits()
455 push_registers_into_stack(thread_self)
456 thread_self.stack.end = get_stack_top()
458 pop_registers_from_stack(thread_self)
463 La variable **global** ``more_to_scan`` indica al algoritmo iterativo cuando
464 debe finalizar: la función ``mark_range()`` (que veremos más adelante) lo pone
465 en ``true`` cuando una nueva celda debe ser visitada, por lo tanto la
466 iteración se interrumpe cuando no hay más celdas por visitar.
468 Las funciones ``stop_the_world()`` y ``start_the_world()`` pausan y reanudan
469 todos los hilos respectivamente (salvo el actual). Al pausar los hilos además
470 se apilan los registros del procesador en el *stack* y se guarda la posición
471 actual del *stack* para que la fase de marcado pueda recorrerlos [#dgcstw]_::
473 function stop_the_world() is
474 foreach thread in threads
475 if thread is thread_self
478 push_registers_into_stack(thread)
479 thread.stack.end = get_stack_top()
481 function start_the_world() is
482 foreach thread in reversed(threads)
483 if thread is thread_self
485 pop_registers_from_stack(thread)
488 .. [#dgcstw] El procedimiento para apilar y desapilar los registros en el
489 *stack* se realiza en realidad utilizando las señales ``SIGUSR1``
490 y ``SIGUSR2`` (respectivamente). Es el manejador de la señal el que en
491 realidad apila y desapila los registros y guarda el puntero al *stack*. Se
492 omiten los detalles para simplificar la explicación del algoritmo.
494 La función ``clear_mark_scan_bits()`` se encarga de restablecer todos los
495 atributos *mark* y *scan* de cada bloque del *heap*::
497 function clear_mark_scan_bits() is
500 foreach block in page
504 La función ``mark_free_lists()`` por su parte se encarga de activar el bit
505 *mark* de todos los bloques de las listas de libres de manera de que la fase
506 de marcado (que es iterativa y realiza varias pasadas sobre **todo** el
507 *heap*, incluyendo las celdas libres) no visite las celdas libres perdiendo
508 tiempo sin sentido y potencialmente manteniendo *vivas* celdas que en
509 realidad son *basura* (*falsos positivos*)::
511 function mark_free_lists() is
512 foreach free_list in free_lists
513 foreach block in free_list
517 Notar que los bloques libres quedan entonces marcados aunque sean *basura* por
518 definición. Para evitar que en la etapa de barrido se tomen estos bloques como
519 celdas vivas, a todos los bloques en la lista de libres también se los marca
520 con el bit *free*, así el barrido puede tomar como *basura* estos bloques
521 aunque estén marcados.
523 El *root set* está compuesto por el área de memoria estática (variables
524 globales), los *stacks* de todos los hilos y los registros del procesador.
525 Primero se marca el área de memoria estática de manera :ref:`conservativa
526 <gc_conserv>` (es decir, tomando cada *word* como si fuera un puntero)::
528 function mark_static_data() is
529 mark_range(static_data.begin, static_data.end)
531 Para poder tomar los registros como parte del *root set* primero se apilan
532 en el *stack* a través de la función::
534 function push_registers_into_stack(thread) is
535 foreach register in thread.registers
538 Y luego, al reiniciar los hilos cuando se termina de marcar, se descartan
539 sacándolos de la pila (no es necesario ni correcto restablecer los valores ya
540 que podrían tener nuevos valores)::
542 function pop_registers_from_stack(thread) is
543 foreach register in reverse(thread.registers)
546 Una vez hecho esto, basta marcar (de forma conservativa) los *stacks* de todos
547 los threads para terminar de marcar el *root set*::
549 function mark_stacks() is
550 foreach thread in threads
551 mark_range(thread.stack.begin, thread.stack.end)
553 Dado que D_ soporta manejo de memoria manual al mismo tiempo que memoria
554 automática, es posible que existan celdas de memoria que no estén en el *root
555 set* convencional ni en el *heap* del recolector. Para evitar que se libere
556 alguna celda a la cual todavía existen referencias desde memoria administrada
557 por el usuario, éste debe informarle al recolector sobre la existencia de
558 estas nuevas raíces. Es por esto que para concluir el marcado del *root set*
559 completo se procede a marcar las raíces definidas por el usuario::
561 function mark_user_roots() is
562 foreach root_range in user_roots
563 mark_range(root_range.begin, root_range.end)
565 El algoritmo de marcado no es recursivo sino iterativo por lo tanto al marcar
566 una celda (o bloque) no se siguen sus *hijas*, solo se activa el bit de *scan*
567 (a menos que la celda no contenga punteros, es decir, tenga el bit *noscan*)::
569 function mark_range(begin, end) is
572 [pool, page, block] = find_block(pointer)
573 if block is not null and block.mark is false
575 if block.noscan is false
577 global more_to_scan = true
580 Por lo tanto en este punto, tenemos todas las celdas inmediatamente
581 alcanzables desde el *root set* marcadas y con el bit *scan* activado si la
582 celda puede contener punteros. Por lo tanto solo resta marcar (nuevamente de
583 forma conservativa) iterativamente todo el *heap* hasta que no hayan más
584 celdas para visitar (con el bit *scan* activo)::
586 function mark_heap() is
587 while global more_to_scan
588 global more_to_scan = false
591 if page.block_size <= PAGE // saltea FREE y CONTINUATION
592 foreach block in page
593 if block.scan is true
595 if page.block_size is PAGE // objeto grande
596 begin = cast(byte*) page
597 end = find_big_object_end(pool, page)
598 mark_range(begin, end)
599 else // objeto pequeño
600 mark_range(block.begin, block.end)
602 Aquí puede verse, con un poco de esfuerzo, la utilización de la
603 :ref:`abstracción tricolor <gc_intro_tricolor>`: todas las celdas alcanzables
604 desde el *root set* son pintadas de *gris* (tienen los bits *mark* y *scan*
605 activados), excepto aquellas celdas atómicas (es decir, que se sabe que no
606 tienen punteros) que son marcadas directamente de *negro*. Luego se van
607 obteniendo celdas del conjunto de las *grises*, se las pinta de *negro* (es
608 decir, se desactiva el bit *scan*) y se pintan todas sus *hijas* de *gris* (o
609 *negro* directamente si no tienen punteros). Este procedimiento se repite
610 mientras el conjunto de celdas *grises* no sea vacío (es decir, que
611 ``more_to_scan`` sea ``true``).
613 A continuación se presenta la implementación de las funciones suplementarias
614 utilizadas en la fase de marcado::
616 function find_big_object_end(pool, page) is
617 pool_end = cast(byte*) pool.pages + (PAGE_SIZE * pool.number_of_pages)
619 page = cast(byte*) page + PAGE_SIZE
620 while page.block_size is CONTINUATION and page < pool_end
623 function find_block(pointer) is
626 if page.block_size is PAGE
627 big_object_start = cast(byte*) page
628 big_object_end = find_big_object_end(pool, page)
629 if big_object_start <= pointer < big_object_end
630 return [pool, page, big_object_start]
631 else if page.block_size < PAGE
632 foreach block in page
633 block_start = cast(byte*) block
634 block_end = block_start + page.block_size
635 if block_start <= pointer < block_end
636 return [pool, page, block_start]
637 return [null, null, null]
639 Cabe destacar que la función ``find_block()`` devuelve el *pool*, la página
640 y el comienzo del bloque al que apunta el puntero, es decir, soporta punteros
648 Esta fase es considerablemente más sencilla que el marcado; el algoritmo puede
649 dividirse en dos pasos básicos::
651 function sweep_phase() is
655 El barrido se realiza con una pasada por sobre todo el *heap* de la siguiente
661 if page.block_size <= PAGE // saltea FREE y CONTINUATION
662 foreach block in page
663 if block.mark is false
664 if block.final is true
669 if page.block_size is PAGE // objeto grande
670 free_big_object(pool, page)
672 Como se observa, se recorre todo el *heap* en busca de bloques y páginas
673 libres. Los bloques libres son marcados con el atributo ``free`` y las páginas
674 libres son marcadas con el tamaño de bloque simbólico ``FREE``. Para los
675 objetos grandes se marcan todas las páginas que utilizaban como ``FREE``::
677 function free_big_object(pool, page) is
678 pool_end = cast(byte*) pool.pages + (PAGE_SIZE * pool.number_of_pages)
680 page.block_size = FREE
681 page = cast(byte*) page + PAGE_SIZE
682 while page < pool_end and page.block_size is CONTINUATION
684 Además, los bloques que tienen en atributo ``final`` son finalizados llamando
685 a la función ``finalize()``. Esta función es un servicio que provee la
686 biblioteca *runtime* y en última instancia llama al destructor del objeto
687 almacenado en el bloque a liberar.
689 Una vez marcados todos los bloques y páginas con ``free``, se procede
690 a reconstruir las listas de libres. Como parte de este proceso se buscan las
691 páginas que tengan todos los bloques libres para marcar la página completa
692 como libre (de manera que pueda utilizarse para albergar otro tamaño de bloque
693 u objetos grandes de ser necesario)::
695 function rebuild_free_lists() is
696 foreach free_list in free_lists
700 if page.block_size < PAGE // objetos pequeños
701 if is_page_free(page)
702 page.block_size = FREE
704 foreach block in page
705 if block.free is true
706 free_lists[page.block_size].link(block)
708 Esta reorganización de listas libres además mejoran la localidad de
709 referencia y previenen la fragmentación. La localidad de referencia se ve
710 mejorada debido a que asignaciones de memoria próximas en el tiempo serán
711 también próximas en espacio porque pertenecerán a la misma página (al menos si
712 las asignaciones son todas del mismo tamaño). La fragmentación se minimiza por
713 el mismo efecto, primero se asignarán todos los bloques de la misma página.
715 A continuación se presenta la implementación de una de las funciones
716 suplementarias de la fase de barrido::
718 function is_page_free(page) is
719 foreach block in page
720 if block.free is false
724 Las demás funciones suplementarias pertenecen a la manipulación de listas
725 libres que no son más que operaciones sobre una lista simplemente enlazada. En
726 la sección :ref:`dgc_impl` se verá con más detalles como las implementa el
732 Asignación de memoria
733 ^^^^^^^^^^^^^^^^^^^^^
734 La asignación de memoria del recolector es relativamente compleja, excepto
735 cuando se asigna un objeto pequeño y ya existe algún bloque con el tamaño
736 preciso en la lista de libres. Para el resto de los casos la cantidad de
737 trabajo que debe hacer el recolector para asignar la memoria es considerable.
739 El algoritmo de asignación de memoria se puede resumir así::
741 function new(size, attrs) is
742 block_size = find_block_size(size)
744 block = new_small(block_size)
746 block = new_big(size)
753 return cast(void*) block
755 La función ``find_block_size()`` sencillamente busca el tamaño de bloque se
756 mejor se ajuste al tamaño solicitado (es decir, el bloque más pequeño lo
757 suficientemente grande como para poder almacenar el tamaño solicitado). Una
758 vez más el algoritmo distingue objetos grandes de pequeños. Los pequeños se
759 asignan de las siguiente manera::
761 function new_small(block_size) is
762 block = find_block_with_size(block_size)
765 block = find_block_with_size(block_size)
768 block = find_block_with_size(block_size)
771 Se intenta reiteradas veces conseguir un bloque del tamaño correcto libre,
772 realizando diferentes acciones si no se tiene éxito. Primero se intenta hacer
773 una :ref:`recolección <dgc_algo_collect>` y si no se puede encontrar
774 suficiente espacio luego de ella se intenta crear un nuevo *pool* de memoria
775 pidiendo memoria al *low level allocator* (el sistema operativo generalmente).
777 Para intentar buscar un bloque de memoria libre se realiza lo siguiente::
779 function find_block_with_size(block_size) is
780 block = free_lists[block_size].pop_first()
782 assign_page(block_size)
783 block = free_lists[block_size].pop_first()
786 Donde ``pop_first()`` retorna ``null`` si la lista estaba vacía. Si no se
787 puede obtener un bloque de la lista de libres correspondiente, se busca
788 asignar una página libre al tamaño de bloque deseado de forma de *alimentar*
789 la lista de libres con dicho tamaño::
791 function assign_page(block_size) is
794 if page.block_size is FREE
795 page.block_size = block_size
796 foreach block in page
797 free_lists[page.block_size].link(block)
799 Cuando todo ello falla, el último recurso consiste en pedir memoria al sistema
800 operativo, creando un nuevo *pool*::
802 function new_pool(number_of_pages = 1) is
803 pool = alloc(pool.sizeof)
806 pool.number_of_pages = number_of_pages
807 pool.pages = alloc(number_of_pages * PAGE_SIZE)
808 if pool.pages is null
813 page.block_size = FREE
816 Se recuerda que la función ``alloc()`` es un :ref:`servicio
817 <gc_intro_services>` provisto por el *low level allocator* y en la
818 implementación actual de D_ en general es el sistema operativo (aunque
819 opcionalmente puede utilizarse la biblioteca estándar de C, que a su vez
820 utiliza el sistema operativo).
822 Cualquier error en estas funciones es propagado y en última instancia, cuando
823 todo falla, la función ``new()`` termina lanzando una excepción indicando que
826 Si el tamaño de bloque necesario para cumplir con la asignación de memoria es
827 de una o más páginas, entonces se utiliza otro algoritmo para alocar un objeto
830 function new_big(size) is
831 number_of_pages = ceil(size / PAGE_SIZE)
832 pages = find_pages(number_of_pages)
835 pages = find_pages(number_of_pages)
838 pool = new_pool(number_of_pages)
841 pages = assign_pages(pool, number_of_pages)
842 pages[0].block_size = PAGE
843 foreach page in pages[1..end]
844 page.block_size = CONTINUATION
847 De forma similar a la asignación de objetos pequeños, se intenta encontrar una
848 serie de páginas contiguas, dentro de un mismo *pool*, suficientes para
849 almacenar el tamaño requerido y si esto falla, se realizan diferentes pasos
850 y se vuelve a intentar. Puede observarse que, a diferencia de la asignación de
851 objetos pequeños, si luego de la recolección no se pudo encontrar lugar
852 suficiente, se trata de minimizar el uso de memoria física utilizando la
853 siguiente función, que devuelve al *low level allocator* los *pools*
854 completamente libres::
856 function minimize() is
860 if page.block_size is not FREE
868 Volviendo a la función ``new_big()``, para hallar una serie de páginas
869 contiguas se utiliza el siguiente algoritmo::
871 function find_pages(number_of_pages) is
873 pages = assign_pages(pool, number_of_pages)
878 Como se dijo, las páginas deben estar contenidas en un mismo *pool* (para
879 tener la garantía de que sean contiguas), por lo tanto se busca *pool* por
880 *pool* dicha cantidad de páginas libres consecutivas a través del siguiente
883 function assign_pages(pool, number_of_pages) is
887 if page.block_size is FREE
892 pages_found = pages_found + 1
893 if pages_found is number_of_pages
894 return [first_page .. page]
900 Una vez más, cuando todo ello falla (incluso luego de una recolección), se
901 intenta alocar un nuevo *pool*, esta vez con una cantidad de páginas
902 suficientes como para almacenar el objeto grande y si esto falla el error se
903 propaga hasta la función ``new()`` que lanza una excepción.
908 Liberación de memoria
909 ^^^^^^^^^^^^^^^^^^^^^
910 La liberación de la memoria asignada puede hacerse explícitamente. Esto
911 saltea el mecanismo de recolección, y es utilizado para dar soporte a manejo
912 explícito de memoria asignada en el *heap* del recolector. En general el
913 usuario no debe utilizar liberación explícita, pero puede ser útil en casos
916 function delete(pointer) is
917 [pool, page, block_start] = find_block(pointer)
922 if page.block_size is PAGE // objeto grande
923 free_big_object(pool, page)
924 else // objeto pequeño
925 free_lists[page.block_size].link(block)
927 Como se puede observar, si el objeto es pequeño se enlaza a la lista de libres
928 correspondiente y si es grande se liberan todas las páginas asociadas a éste,
929 de forma similar a la :ref:`fase de barrido <dgc_algo_sweep>`. A diferencia de
930 ésta, no se finaliza el objeto (es decir, no se llama a su destructor).
937 Al finalizar el programa, el recolector es finalizado también y lo que realiza
938 actualmente, además de liberar la memoria propia del recolector, es realizar
939 una recolección. Es decir, si hay objetos que son todavía alcanzables desde el
940 *root set*, esos objetos no son finalizados (y por lo tanto sus destructores
943 Como se ha visto, esto es perfectamente válido ya que D_ no garantiza que los
944 objetos sean finalizados.
950 Detalles de implementación
951 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
953 Hay varias diferencias a nivel de implementación entre lo que se presentó en
954 las secciones anteriores y como está escrito realmente el recolector actual.
955 Con los conceptos e ideas principales ya explicadas, se procede a ahondar con
956 más detalle en como está construido el recolector y algunas de sus
957 optimizaciones principales.
959 Vale aclarar que el recolector de basura actual está implementado en D_.
962 Estructuras de datos del recolector
963 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
964 El recolector está principalmente contenido en la estructura llamada ``Gcx``.
965 Dicha estructura tiene los siguientes atributos (divididos en categorías para
966 facilitar la comprensión):
968 Raíces definidas por el usuario
969 *roots* (*nroots*, *rootdim*)
970 Arreglo variable de punteros simples que son tomados como raíces
971 provistas por el usuario.
973 *ranges* (*nranges*, *rangedim*)
974 Arreglo variable de rangos de memoria que deben ser revisados (de forma
975 conservativa) como raíces provistas por el usuario. Un rango es una
976 estructura con dos punteros: ``pbot`` y ``ptop``. Toda la memoria entre
977 estos dos punteros se toma, palabra por palabra, como una raíz del
980 Estado interno del recolector
982 Variable que indica si en la fase de marcado se encontraron nuevas
983 celdas con punteros que deban ser visitados. Otra forma de verlo es como
984 un indicador de si el conjunto de celdas *grises* está vacío luego de
985 una iteración de marcado (utilizando la :ref:`abstracción tricolor
986 <gc_intro_tricolor>`). Es análoga a la variable ``more_to_scan``
987 presentada en :ref:`dgc_algo_mark`.
990 Indica si el recolector fue inicializado.
993 Puntero a la base del *stack* (asumiendo que el stack crece hacia arriba).
994 Se utiliza para saber por donde comenzar a visitar el *stack* de forma
995 conservativa, tomándolo con una raíz del recolector.
997 *Pools* (*pooltable*, *npools*)
998 Arreglo variable de punteros a estructuras ``Pool`` (ver más adelante).
999 Este arreglo se mantiene siempre ordenado de menor a mayor según la
1000 dirección de memoria de la primera página que almacena.
1003 Listas de libres. Es un arreglo de estructuras ``List`` utilizadas para
1004 guardar la listas de libres de todos los tamaños de bloques posibles (ver
1007 Atributos que cambian el comportamiento
1009 Indica que no debe tomarse al *stack* como raíz del recolector. Esto es
1010 muy poco seguro y no debería ser utilizado nunca, salvo casos
1011 extremadamente excepcionales.
1014 Indica si se debe guardar un registro de la actividad del recolector. Es
1015 utilizado principalmente para depuración.
1018 Indica que no se deben realizar recolecciones implícitamente. Si al
1019 tratar de asignar memoria no se puede hallar celdas libres en el *heap*
1020 del recolector, se pide más memoria al sistema operativo sin correr una
1021 recolección para intentar recuperar espacio. Esto es particularmente
1022 útil para secciones de un programa donde el rendimiento es crítico y no
1023 se pueden tolerar grandes pausas como las que puede provocar el
1027 *p_cache*, *size_cache*
1028 Caché del tamaño de bloque para un puntero dado. Obtener el tamaño de un
1029 bloque es una tarea costosa y común. Para evitarla en casos donde se
1030 calcula de forma sucesiva el tamaño del mismo bloque (como puede ocurrir
1031 al concatenar arreglos dinámicos) se guarda en un caché (de un solo
1032 elemento) el último valor calculado.
1034 *minAddr*, *maxAddr*
1035 Punteros al principio y fin del *heap*. Pueden haber *huecos* entre
1036 estos dos punteros que no pertenezcan al *heap* pero siempre se cumple
1037 que si un puntero apunta al *heap* debe estar en este rango. Esto es
1038 útil para hacer un cálculo rápido para descartar punteros que fueron
1039 tomados de forma conservativa y en realidad no apuntan al *heap* (ver la
1040 función ``find_block()`` en :ref:`dgc_algo_mark`).
1045 La primera diferencia es como está organizado el *heap*. Si bien la
1046 explicación presentada en la sección :ref:`dgc_org` es correcta, la forma en
1047 la que está implementado no es tan *naïve* como los algoritmos presentados en
1048 :ref:`dgc_algo` sugieren.
1050 El recolector guarda un arreglo variable de estructuras ``Pool``. Cabe
1051 destacar que para implementar el recolector no se pueden utilizar los arreglos
1052 dinámicos de D_ (ver sección :ref:`d_high_level`) dado que éstos utilizan de
1053 forma implícita el recolector de basura, por lo tanto todos los arreglos
1054 variables del recolector se implementan utilizando las funciones de
1055 C :manpage:`malloc(3)`, :manpage:`realloc(3)` y :manpage:`free(3)`
1059 La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura
1060 :vref:`fig:dgc-pool`):
1062 .. flt:: fig:dgc-pool
1064 Vista gráfica de la estructura de un *pool* de memoria
1069 /--- "baseAddr" "ncommitted = i" "topAddr" ---\
1072 +---- "committed" -----+------- "no committed" ----------+
1075 +--------+--------+-----+--------+-----+-------------------+
1076 páginas | 0 | 0 | ... | i | ... | "npages - 1" |
1077 +--------+--------+-----+--------+-----+-------------------+
1080 +--------+--------+-----+--------+-----+-------------------+
1081 pagetable | Bins 0 | Bins 1 | ... | Bins i | ... | "Bins (npages-1)" |
1082 +--------+--------+-----+--------+-----+-------------------+
1084 *baseAddr* y *topAddr*
1085 Punteros al comienzo y fin de la memoria que almacena todas las páginas del
1086 *pool* (*baseAddr* es análogo al atributo *pages* utilizado en las
1087 secciones anteriores para mayor claridad).
1089 *mark*, *scan*, *freebits*, *finals*, *noscan*
1090 Conjuntos de bits (*bitsets*) para almacenar los indicadores descriptos en
1091 :ref:`dgc_org` para todos los bloques de todas las páginas del *pool*.
1092 *freebits* es análogo a *free* y *finals* a *final* en los atributos
1093 descriptos en las secciones anteriores.
1096 Cantidad de páginas que contiene este *pool* (fue nombrado
1097 *number_of_pages* en las secciones anteriores para mayor claridad).
1100 Cantidad de páginas *encomendadas* al sistema operativo (*committed* en
1101 inglés). Este atributo no se mencionó anteriormente porque el manejo de
1102 páginas encomendadas le agrega una complejidad bastante notable al
1103 recolector y es solo una optimización para un sistema operativo en
1104 particular (Microsoft Windows).
1107 Arreglo de indicadores de tamaño de bloque de cada página de este *pool*.
1108 Los indicadores válidos son ``B_16`` a ``B_2048`` (pasando por los valores
1109 posibles de bloque mencionados anteriormente, todos con el prefijo
1110 "``B_``"), ``B_PAGE``, ``B_PAGEPLUS`` (análogo a ``CONTINUATION``),
1111 ``B_UNCOMMITTED`` (valor que tienen las páginas que no fueron encomendadas
1114 Como se observa, además de la información particular del *pool* se almacena
1115 toda la información de páginas y bloques enteramente en el *pool* también.
1116 Esto simplifica el manejo de lo que es memoria *pura* del *heap*, ya que queda
1117 una gran porción continua de memoria sin estar intercalada con
1118 meta-información del recolector.
1120 Para poder acceder a los bits de un bloque en particular, se utiliza la
1121 siguiente cuenta para calcular el índice en el *bitset*:
1125 index(p) = \frac{p - baseAddr}{16}
1127 Donde ``p`` es la dirección de memoria del bloque. Esto significa que, sin
1128 importar cual es el tamaño de bloque de las páginas del *pool*, el *pool*
1129 siempre reserva suficientes bits como para que todas las páginas puedan tener
1130 tamaño de bloque de 16 bytes. Esto puede ser desperdiciar bastante espacio si
1131 no predomina un tamaño de bloque pequeño.
1136 Las listas de libres se almacenan en el recolector como un arreglo de
1137 estructuras ``List``, que se compone solamente de un atributo ``List* next``
1138 (es decir, un puntero al siguiente). Entonces cada elemento de ese arreglo es
1139 un puntero al primer elemento de la lista en particular.
1141 La implementación utiliza a los bloques de memoria como nodos directamente.
1142 Como los bloques siempre pueden almacenar una palabra (el bloque de menor
1143 tamaño es de 16 bytes y una palabra ocupa comúnmente entre 4 y 8 bytes según
1144 se trabaje sobre arquitecturas de 32 o 64 bits respectivamente), se almacena
1145 el puntero al siguiente en la primera palabra del bloque.
1150 Los algoritmos en la implementación real son considerablemente menos modulares
1151 que los presentados en la sección :ref:`dgc_algo`. Por ejemplo, la función
1152 ``collect()`` es una gran función de 300 líneas de código fuente.
1154 A continuación se resumen las funciones principales, separadas en categorías
1155 para facilitar la comprensión. Los siguientes son métodos de la estructura
1158 Inicialización y terminación
1160 Inicializa las estructuras internas del recolector para que pueda ser
1161 utilizado. Esta función la llama la biblioteca *runtime* antes de que el
1162 programa comience a correr.
1165 Libera todas las estructuras que utiliza el recolector.
1167 Manipulación de raíces definidas por el usuario
1168 *addRoot(p)*, *removeRoot(p)*, *rootIter(dg)*
1169 Agrega, remueve e itera sobre las raíces simples definidas por el
1172 *addRange(pbot, ptop)*, *remove range(pbot)*, *rangeIter(dg)*
1173 Agrega, remueve e itera sobre los rangos de raíces definidas por el
1176 Manipulación de bits indicadores
1177 *getBits(pool, biti)*
1178 Obtiene los indicadores especificados para el bloque de índice ``biti``
1179 en el *pool* ``pool``.
1181 *setBits(pool, biti, mask)*
1182 Establece los indicadores especificados en ``mask`` para el bloque de
1183 índice ``biti`` en el *pool* ``pool``.
1185 *clrBits(pool, biti, mask)*
1186 Limpia los indicadores especificados en ``mask`` para el bloque de
1187 índice ``biti`` en el *pool* ``pool``.
1189 Cada bloque (*bin* en la terminología de la implementación del recolector)
1190 tiene ciertos indicadores asociados. Algunos de ellos pueden ser
1191 manipulados (indirectamente) por el usuario utilizando las funciones
1194 El parámetro ``mask`` debe ser una máscara de bits que puede estar
1195 compuesta por la conjunción de los siguientes valores:
1198 El objeto almacenado en el bloque tiene un destructor (indicador
1202 El objeto almacenado en el bloque no contiene punteros (indicador
1206 El objeto almacenado en el bloque no debe ser movido [#dgcmove]_.
1208 .. [#dgcmove] Si bien el recolector actual no tiene la capacidad de mover
1209 objetos, la interfaz del recolector hacer que sea posible una
1210 implementación que lo haga, ya que a través de este indicador se pueden
1211 fijar objetos apuntados desde algún segmento no conservativo (objeto
1216 Busca el *pool* al que pertenece el objeto apuntado por ``p``.
1219 Busca la dirección base (el inicio) del bloque apuntado por ``p``
1220 (``find_block()`` según la sección :ref:`dgc_algo_mark`).
1223 Busca el tamaño del bloque apuntado por ``p``.
1226 Obtiene información sobre el bloque apuntado por ``p``. Dicha
1227 información se retorna en una estructura ``BlkInfo`` que contiene los
1228 siguientes atributos: ``base`` (dirección del inicio del bloque),
1229 ``size`` (tamaño del bloque) y ``attr`` (atributos o indicadores del
1230 bloque, los que se pueden obtener con ``getBits()``).
1233 Calcula el tamaño de bloque más pequeño que pueda contener un objeto de
1234 tamaño ``size`` (``find_block_size()`` según lo visto en
1235 :ref:`dgc_algo_alloc`).
1237 Asignación de memoria
1239 Reserva un nuevo *pool* de al menos ``size`` bytes. El algoritmo nunca
1240 crea un *pool* con menos de 256 páginas (es decir, 1 MiB).
1243 Minimiza el uso de la memoria retornando *pools* sin páginas usadas al
1247 Reserva un nuevo *pool* con al menos ``n`` páginas. Junto con
1248 ``Pool.initialize()`` es análoga a ``new_pool()``, solo que esta función
1249 siempre incrementa el número de páginas a, al menos, 256 páginas (es
1250 decir, los *pools* son siempre mayores a 1 MiB). Si la cantidad de
1251 páginas pedidas supera 256, se incrementa el número de páginas en un 50%
1252 como para que sirva para futuras asignaciones también. Además a medida
1253 que la cantidad de *pools* crece, también trata de obtener cada vez más
1254 memoria. Si ya había un *pool*, el 2do tendrá como mínimo 2 MiB, el 3ro
1255 3 MiB y así sucesivamente hasta 8 MiB. A partir de ahí siempre crea
1256 *pools* de 8 MiB o la cantidad pedida, si ésta es mayor.
1258 *Pool.initialize(n_pages)*
1259 Inicializa un nuevo *pool* de memoria. Junto con ``newPool()`` es
1260 análoga a ``new_pool()``. Mientras ``newPool()`` es la encargada de
1261 calcular la cantidad de páginas y crear el objeto *pool*, esta función
1262 es la que pide la memoria al sistema operativo. Además inicializa los
1263 conjuntos de bits: ``mark``, ``scan``, ``freebits``, ``noscan``.
1264 ``finals`` se inicializa de forma perezosa, cuando se intenta asignar el
1265 atributo ``FINALIZE`` a un bloque, se inicializa el conjunto de bits
1266 ``finals`` de todo el *pool*.
1269 Asigna a una página libre el tamaño de bloque ``bin`` y enlaza los
1270 nuevos bloques libres a la lista de libres correspondiente (análogo
1271 a ``assign_page()``).
1274 Busca ``n`` cantidad de páginas consecutivas libres (análoga
1275 a ``find_pages(n)``).
1277 *malloc(size, bits)*
1278 Asigna memoria para un objeto de tamaño ``size`` bytes. Análoga al
1279 algoritmo ``new(size, attr)`` presentado, excepto que introduce además
1280 un caché para no recalcular el tamaño de bloque necesario si se realizan
1281 múltiples asignaciones consecutivas de objetos del mismo tamaño y que la
1282 asignación de objetos pequeños no está separada en una función aparte.
1285 Asigna un objeto grande (análogo a ``new_big()``). La implementación es
1286 mucho más compleja que la presentada en ``new_big()``, pero la semántica
1287 es la misma. La única diferencia es que esta función aprovecha que
1288 ``fullcollectshell()`` / ``fullcollect()`` retornan la cantidad de
1289 páginas liberadas en la recolección por lo que puede optimizar levemente
1290 el caso en que no se liberaron suficientes páginas para asignar el
1291 objeto grande y pasar directamente a crear un nuevo *pool*.
1294 Libera la memoria apuntada por ``p`` (análoga a ``delete()`` de la
1297 Recordar que la ``pooltable`` siempre se mantiene ordenada según la
1298 dirección de la primera página.
1302 Marca un rango de memoria. Este método es análogo al ``mark_range()``
1303 presentado en la sección :ref:`dgc_algo_mark`.
1305 *fullcollectshell()*
1306 Guarda los registros del procesador asignado al hilo actual en su
1307 *stack* y llama a ``fullcollect()``. El resto de los hilos son pausados
1308 y sus registros apilados por la función del *runtime*
1309 ``thread_suspendAll()`` (y restablecidos y reiniciados por
1310 ``thread_resumeAll()``.
1312 *fullcollect(stackTop)*
1313 Realiza la recolección de basura. Es análoga a ``collect()`` pero es
1314 considerablemente menos modular, todos los pasos se hacen directamente
1315 en esta función: marcado del *root set*, marcado iterativo del *heap*,
1316 barrido y reconstrucción de la lista de libres. Además devuelve la
1317 cantidad de páginas que se liberaron en la recolección, lo que permite
1318 optimizar levemente la función ``bigAlloc()``.
1323 El recolector actual, por omisión, solamente efectúa una recolección al
1324 finalizar. Por lo tanto, no se ejecutan los destructores de todos aquellos
1325 objetos que son alcanzables desde el *root set* en ese momento. Existe la
1326 opción de no realizar una recolección al finalizar el recolector, pero no de
1327 finalizar *todos* los objetos (alcanzables o no desde el *root set*). Si bien
1328 la especificación de D_ permite este comportamiento (de hecho la
1329 especificación de D_ es tan vaga que permite un recolector que no llame jamás
1330 a ningún destructor), para el usuario puede ser una garantía muy débil
1331 y proveer finalización asegurada puede ser muy deseable.
1336 Memoria *encomendada*
1337 ^^^^^^^^^^^^^^^^^^^^^
1338 El algoritmo actual divide un *pool* en dos áreas: memoria *encomendada*
1339 (*committed* en inglés) y *no-encomendada*. Esto se debe a que originalmente
1340 el compilador de D_ DMD_ solo funcionaba en Microsoft Windows y este sistema
1341 operativo puede asignar memoria en dos niveles. En principio se puede asignar
1342 al proceso un espacio de memoria (*address space*) pero sin asignarle la
1343 memoria virtual correspondiente. En un paso posterior se puede *encomendar* la
1344 memoria (es decir, asignar realmente la memoria virtual).
1346 Para aprovechar esta característica el recolector diferencia estos dos
1347 niveles. Sin embargo, esta diferenciación introduce una gran complejidad (que
1348 se omitió en las secciones anteriores para facilitar la comprensión),
1349 y convierte lo que es una ventaja en un sistema operativo en una desventaja
1350 para todos los demás (ya que los cálculos extra se realizan pero sin ningún
1351 sentido). De hecho hay sistemas operativos, como Linux_, que realizan este
1352 trabajo automáticamente (la memoria no es asignada realmente al programa hasta
1353 que el programa no haga uso de ella; a esta capacidad se la denomina
1356 Como se vio en la figura :vref:`fig:dgc-pool`, las páginas de un *pool* se
1357 dividen en *committed* y *uncommitted*. Siempre que el recolector recorre un
1358 *pool* en busca de una página o bloque, lo hace hasta la memoria *committed*,
1359 porque la *uncommitted* es como si jamás se hubiera pedido al sistema
1360 operativo a efectos prácticos. Además, al buscar páginas libres, si no se
1361 encuentran entre las *encomendadas* se intenta primero *encomendar* páginas
1362 nuevas antes de crear un nuevo *pool*.
1367 Si bien el recolector no es paralelo ni concurrente (ver :ref:`gc_art`),
1368 soporta múltiples *mutator*\ s. La forma de implementarlo es la más simple.
1369 Todas las operaciones sobre el recolector que se llaman externamente están
1370 sincronizadas utilizando un *lock* global (excepto cuando hay un solo hilo
1371 *mutator*, en cuyo caso se omite la sincronización). Esto afecta también a la
1372 asignación de memoria y cualquier otro servicio provisto por el recolector.
1378 Características destacadas
1379 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1381 Si bien el recolector en términos generales no se aleja mucho de un
1382 :ref:`marcado y barrido clásico <gc_mark_sweep>`, tiene algunas mejoras por
1383 sobre el algoritmo más básicos que vale la pena destacar:
1386 Organización del *heap*
1387 ^^^^^^^^^^^^^^^^^^^^^^^
1388 El *heap* está organizado de una forma que, si bien no emplea las técnicas más
1389 modernas que pueden observarse en el estado del arte (como :ref:`regiones
1390 <gc_free_list>`), es relativamente sofisticada. El esquema de *pools*
1391 y bloques permite disminuir considerablemente los problemas de *fragmentación*
1392 de memoria y evita búsquedas de *huecos* que pueden ser costosas (como
1393 *best-fit* [#dgcbestfit]_) o desperdiciar mucho espacio (como *first-fit*
1394 [#dgcfirstfit]_), logrando un buen equilibrio entre velocidad y espacio
1397 .. [#dgcbestfit] Las búsquedas de tipo *best-fit* son aquellas donde se busca
1398 el *hueco* en el *heap* (es decir, una región contínua de memoria
1399 libre) que mejor se ajuste al tamaño del objeto a asignar. Es decir, el
1400 *hueco* más pequeño lo suficientemente grande como para almacenarlo.
1402 .. [#dgcfirstfit] Las búsquedas de tipo *first-fit* son aquellas donde se busca
1403 el primer *hueco* en el *heap* (es decir, una región contínua de memoria
1404 libre) que sea lo suficientemente grande como para almacenar el objeto
1408 Fase de marcado iterativa
1409 ^^^^^^^^^^^^^^^^^^^^^^^^^
1410 A diferencia del algoritmo clásico recursivo, el algoritmo del recolector
1411 actual es iterativo. El algoritmo recursivo tiene un problema fundamental: se
1412 puede llegar a un desbordamiento de pila (o *stack overflow*). La cantidad de
1413 recursiones necesarias es, en el peor caso, :math:`O(|Live \thickspace set|)`
1414 (por ejemplo, si todas las celdas del *heap* formaran una lista simplemente
1415 enlazada). Hay muchas técnicas para lidiar con este problema, algunas que
1416 podrían aplicarse a D_ y otras que no (como *pointer reversal*) [JOLI96]_. El
1417 recolector actual, sin embargo, cambia complejidad en espacio por complejidad
1418 en tiempo, utilizando un algoritmo iterativo que es constante (:math:`O(1)`)
1419 en espacio, pero que requiere varias pasada sobre el *heap* en vez de una (la
1420 cantidad de pasadas en el peor caso es :math:`O(|Live \thickspace set|)`, al
1421 igual que la profundidad del algoritmo recursivo, pero cada pasada se realiza
1422 sobre todo el *heap*).
1425 Conjuntos de bits para indicadores
1426 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1427 El algoritmo clásico propone almacenar en la propia celda la marca (para la
1428 fase de marcado) y otros indicadores. El algoritmo del recolector actual
1429 utiliza conjuntos de bits. Esto trae dos ventajas principales:
1431 * Permite minimizar el espacio requerido, ya que de otra forma en general se
1432 desperdicia una palabra entera como cabecera de celda para guardar este tipo
1435 * Mejora la localidad de referencia, ya que los indicadores se escriben de
1436 forma muy compacta y en una región de memoria contigua que generalmente
1437 puede entrar en el cache o en pocas páginas de memoria acelerando
1438 considerablemente la fase de marcado.
1443 Herramientas para depuración
1444 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1446 El recolector provee algunas opciones para simplificar el diagnóstico
1447 y depuración de problemas, tanto del mismo recolector como del programa del
1450 Las opciones más importantes son:
1454 Su función es escribir un patrón determinado de bits en todos los bytes de
1455 un bloque de memoria según se haya:
1457 * Pedido un bloque menor a una página (``0xF0``).
1458 * Pedido un bloque mayor a una página (``0xF1``).
1459 * Dejado de usar debido a un pedido de achicamiento de un bloque
1461 * Pedido más páginas debido a un pedido de agrandamiento de un bloque
1463 * Liberado intencionalmente por el usuario (``0xF2``).
1464 * Barrido (``0xF3``).
1466 Esto permite al diagnosticar un problema saber, por ejemplo, si un
1467 determinado área de memoria fue recolectada recientemente, o liberada por
1468 el usuario, o recién adquirida, etc. con tan solo ver si un patrón de bits
1469 determinado está presente. Por supuesto puede existir *falsos positivos*
1470 pero su probabilidad es lo suficientemente baja como para que sea útil en
1474 Su función detectar errores producidos por escribir más allá (o antes) del
1475 área de memoria solicitada. Está implementado reservando un poco más de
1476 memoria de la que pide el usuario y devolviendo un puntero a un bloque
1477 ubicado dentro del bloque real reservado (en vez de al inicio). Escribiendo
1478 un patrón de bits en los extremos del bloque real (ver figura
1479 :vref:`fig:sentinel`) se puede verificar, en distintas situaciones (como
1480 por ejemplo al barrer el bloque), que esas guardas con los patrones de bits
1481 estén intactas (en caso contrario se ha escrito por fuera de los límites
1482 del bloque solicitado). Esto permite detectar de forma temprana errores
1483 tanto en el recolector como en el programa del usuario.
1485 .. flt:: fig:sentinel
1487 Esquema de un bloque cuando está activada la opción ``SENTINEL``
1493 +-- Palabra ---+-- Palabra ---+-- Tamaño bloque de usuario --+- Byte -+
1496 +--------------+--------------+------------------------------+--------+
1497 | "Tamaño del" | Pre | | Post |
1498 | "bloque de" | | Bloque de usuario | |
1499 | "usuario" | 0xF4F4F4F4 | | 0xF5 |
1500 +--------------+--------------+------------------------------+--------+
1503 Puntero devuleto ---/
1505 Ambas opciones son seleccionables sólo en tiempo de compilación del
1506 recolector, por lo que su utilidad real, al menos para el usuario, se ve
1507 severamente reducida.
1512 Problemas y limitaciones
1513 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1515 A continuación se presentan los principales problemas encontrados en la
1516 implementación actual del recolector de basura de D_. Estos problemas surgen
1517 principalmente de la observación del código y de aproximadamente tres años de
1518 participación y observación del grupo de noticias, de donde se obtuvieron los
1519 principales problemas percibidos por la comunidad que utiliza el lenguaje.
1524 Complejidad del código y documentación
1525 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1526 El análisis del código fue muy complicado debido a la falta de documentación
1527 y desorganización del código. Además se nota que el recolector ha sido escrito
1528 en una fase muy temprana y que a ido evolucionando a partir de ello de forma
1529 descuidada y sin ser rescrito nunca para aprovechar las nuevas características
1530 que el lenguaje fue incorporando (por ejemplo *templates*).
1532 Estos dos problemas (código complicado y falta de documentación) producen un
1533 efecto de círculo vicioso, porque provocan que sea complejo entender el
1534 recolector actual y en consecuencia sea muy complicado escribir documentación
1535 o mejorarlo. Esto a su vez provoca que, al no disponer de una implementación
1536 de referencia sencilla, sea muy difícil implementar un recolector nuevo.
1540 Este es, probablemente, la raíz de todos los demás problemas del recolector
1541 actual. Para ilustrar la dimensión del problema se presenta la implementación
1542 real de la función ``bigAlloc()``::
1545 * Allocate a chunk of memory that is larger than a page.
1546 * Return null if out of memory.
1548 void *bigAlloc(size_t size)
1558 npages = (size + PAGESIZE - 1) / PAGESIZE;
1562 // This code could use some refinement when repeatedly
1563 // allocating very large arrays.
1565 for (n = 0; n < npools; n++)
1567 pool = pooltable[n];
1568 pn = pool.allocPages(npages);
1582 freedpages = fullcollectshell();
1583 if (freedpages >= npools * ((POOLSIZE / PAGESIZE) / 4))
1587 // Release empty pools to prevent bloat
1589 // Allocate new pool
1590 pool = newPool(npages);
1595 pn = pool.allocPages(npages);
1596 assert(pn != OPFAIL);
1599 // Release empty pools to prevent bloat
1601 // Allocate new pool
1602 pool = newPool(npages);
1605 pn = pool.allocPages(npages);
1606 assert(pn != OPFAIL);
1616 pool.pagetable[pn] = B_PAGE;
1618 cstring.memset(&pool.pagetable[pn + 1], B_PAGEPLUS, npages - 1);
1619 p = pool.baseAddr + pn * PAGESIZE;
1620 cstring.memset(cast(char *)p + size, 0, npages * PAGESIZE - size);
1621 debug (MEMSTOMP) cstring.memset(p, 0xF1, size);
1622 //debug(PRINTF) printf("\tp = %x\n", p);
1626 return null; // let mallocNoSync handle the error
1629 Se recuerda que la semántica de dicha función es la misma que la de la función
1630 ``new_big()`` presentada en :ref:`dgc_algo_alloc`.
1632 Además, como se comentó en la sección anterior, los algoritmos en la
1633 implementación real son considerablemente menos modulares que los presentados
1634 en la sección :ref:`dgc_algo`. Por ejemplo, la función ``fullcollect()`` tiene
1635 300 líneas de código fuente.
1638 Memoria *encomendada*
1639 ^^^^^^^^^^^^^^^^^^^^^
1640 Como se comentó en la sección anterior, diferenciar entre memoria
1641 *encomendada* de memoria *no-encomendada* es complejo y levemente costoso (en
1642 particular para sistemas operativos que no hacen esta distinción, al menos
1643 explícitamente, donde no hay ningún beneficio en realizar esta distinción).
1645 Incluso para Microsoft Windows, la ventaja de realizar esta distinción debería
1651 Este fue históricamente uno de los problemas principales del recolector de D_
1652 [NGD46407]_ [NGD35364]_. Sin embargo, desde que, en la versión 1.001, se ha
1653 incorporado la capacidad de marcar un bloque como de datos puros (no contiene
1654 punteros, el atributo ``NO_SCAN``) [NGA6842]_, la gravedad de esos problemas ha
1655 disminuido considerablemente, aunque siguieron reportándose problemas más
1656 esporádicamente [NGD54084]_ [NGL13744]_.
1658 De todas maneras queda mucho lugar para mejoras, y es un tema recurrente en el
1659 grupo de noticias de D_ y se han discutido formas de poder hacer que, al menos
1660 el *heap* sea preciso [NGD44607]_ [NGD29291]_. Además se mostró un interés
1661 general por tener un recolector más preciso [NGD87831]_, pero no han habido
1662 avances al respecto hasta hace muy poco tiempo.
1664 Otra forma de minimizar los efectos de la falta de precisión que se ha
1665 sugerido reiteradamente en el grupo es teniendo la
1666 posibilidad de indicar cuando no pueden haber punteros interiores a un bloque
1667 [NGD89394]_ [NGD71869]_. Esto puede ser de gran utilidad para objetos grandes
1668 y en particular para mejorar la implementación de de arreglos asociativos.
1673 Si bien el recolector de Tango_ tiene un soporte limitado de *referencias
1674 débiles* [#dgcweakref]_, el de Phobos_ no dispone de ningún soporte (por lo
1675 tanto no está contemplado oficialmente el lenguaje). Sin embargo hay una
1676 demanda apreciable [NGD86840]_ [NGD13301]_ [NGL8264]_ [NGD69761]_ [NGD74624]_
1679 .. [#dgcweakref] Una referencia débil (o *weak reference* en inglés) es
1680 aquella que que no protege al objeto referenciado de ser reciclado por el
1683 Para cubrir esta demanda, se han implementado soluciones como biblioteca para
1684 suplir la inexistencia de una implementación oficial [NGA9103]_ (la
1685 implementación de Tango_ es otro ejemplo).
1687 Sin embargo éstas son en general poco robustas, extremadamente dependientes de
1688 la implementación del recolector y, en general, presentan problemas muy
1689 sutiles [NGD88065]_. Por esta razón se ha discutido la posibilidad de incluir
1690 la implementación de *referencias débiles* como parte del lenguaje
1696 El soporte actual de concurrencia, en todos sus aspectos, es muy primitivo. El
1697 recolector apenas soporta múltiples *mutators* pero con un nivel de
1698 sincronización excesivo.
1700 Se ha sugerido en el pasado el uso de *pools* y listas de libres específicos
1701 de hilos, de manera de disminuir la contención, al menos para la asignación de
1702 memoria [NGD75952]_ [NGD87831]_.
1704 Además se ha mostrado un interés por tener un nivel de concurrencia aún mayor
1705 en el recolector, para aumentar la eficiencia en ambientes *multi-core* en
1706 general pero en particular para evitar grandes pausas en programas con
1707 requerimientos de tiempo real, históricamente una de las principales críticas
1708 al lenguaje [NGD87831]_ [NGL3937]_ [NGD22968]_ [NGA15246]_ [NGD5622]_
1709 [NGD2547]_ [NGD18354]_.
1714 El recolector actual no garantiza la finalización de objetos. En particular
1715 los objetos no son finalizados (es decir, no se llama a sus destructores) si
1716 aún alcanzables desde el *root set* cuando el programa termina. Cabe destacar
1717 que esto puede darse porque hay una referencia real desde el *root set* (en
1718 cuyo caso queda bajo el control del usuario) pero también, dado que el *root
1719 set* se visita de forma conservativa, se puede deber a un *falso positivo*, en
1720 cuyo caso la omisión de la finalización queda por completo fuera del control
1721 del usuario (y lo que es aún peor, el usuario no puede ser siquiera notificado
1724 Si bien la especificación de D_ no requiere esta capacidad, no hay mayores
1725 problemas para implementar un recolector que dé este tipo de garantías
1728 Además los objetos pueden ser finalizados tanto determinísticamente
1729 (utilizando ``delete`` o ``scope``; ver secciones :ref:`d_low_level`
1730 y :ref:`d_dbc`) como no determinísticamente (cuando son finalizados por el
1731 recolector). En el primer caso se puede, por ejemplo, acceder sus atributos
1732 u otra memoria que se conozca *viva*, mientras que en el segundo no. Sin
1733 embargo un destructor no puede hacer uso de esta distinción, haciendo que la
1734 finalización determinística tenga a fines prácticos las mismas restricciones
1735 que la finalización no determinística. Es por esto que se ha sugerido permitir
1736 al destructor distinguir estos dos tipos de finalización [NGD89302]_.
1741 El rendimiento en general del recolector es una de las críticas frecuentes. Si
1742 bien hay muchos problemas que han sido resueltos, en especial por la inclusión
1743 de un mínimo grado de precisión en la versión 1.001, en la actualidad se
1744 siguen encontrando en el grupo de noticias críticas respecto a esto
1745 [NGD43991]_ [NGD67673]_ [NGD63541]_ [NGD90977]_.
1747 La principal causa del bajo rendimiento del recolector actual es,
1748 probablemente, lo simple de su algoritmo principal de recolección. Más allá de
1749 una organización del *heap* moderadamente apropiada y de utilizar conjuntos de
1750 bits para la fase de marcado, el resto del algoritmo es casi la versión más
1751 básica de marcado y barrido. Hay mucho lugar para mejoras en este sentido.
1756 Si bien el recolector actual tiene algunas características configurables,
1757 todas son seleccionables sólo en tiempo de compilación del recolector (no del
1758 programa del usuario), como por ejemplo las opciones descriptas en
1759 :ref:`dgc_debug`. Por lo tanto, a nivel práctico, es como si no tuviera
1760 posibilidad alguna de ser configurado por el usuario, ya que no es parte del
1761 ciclo de desarrollo normal el recompilar el recolector o *runtime* de un
1764 Dado que es imposible que un recolector sea óptimo para todo tipo de
1765 programas, es muy deseable permitir una configuración de parámetros del
1766 recolector que permitan al usuario ajustarlos a las necesidades particulares
1767 de sus aplicaciones.
1772 Factor de ocupación del *heap*
1773 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1774 Otro problema potencialmente importante del recolector actual es que no se
1775 tiene ningún cuidado con respecto a que, luego de una recolección, se haya
1776 recuperado una buena parte del *heap*. Por lo tanto, en casos extremos, el
1777 recolector tiene que hacer una recolección por cada petición de memoria, lo
1778 que es extremadamente ineficiente.
1780 Para evitar esto, habría que usar algún esquema para evaluar cuando una
1781 recolección no fue lo suficientemente *exitosa* y en ese caso pedir más
1782 memoria al sistema operativo.
1787 Finalmente hay varios detalles en la implementación actual que podrían
1791 Hay 12 listas de libres, como para guardar bloques de tamaño de ``B_16``
1792 a ``B_2048``, ``B_PAGE``, ``B_PAGEPLUS``, ``B_UNCOMMITTED`` y ``B_FREE``;
1793 sin embargo solo tienen sentido los bloques de tamaño ``B_16``
1794 a ``B_2048``, por lo que 4 de esas listas no se utilizan.
1796 Conjuntos de bits para indicadores
1797 Los indicadores para la fase de marcado y otras propiedades de un bloque
1798 son almacenados en conjuntos de bits que almacenan los indicadores de todos
1799 los bloques de un *pool*. Si bien se ha mencionado esto como una ventaja,
1800 hay lugar todavía como para algunas mejoras. Como un *pool* tiene páginas
1801 con distintos tamaños de bloque, se reserva una cantidad de bits igual a la
1802 mayor cantidad posible de bloques que puede haber en el *pool*; es decir,
1803 se reserva 1 bit por cada 16 bytes del *pool*. Para un *pool* de 1 MiB
1804 (tamaño mínimo), teniendo en cuenta que se utilizan 5 conjuntos de bits
1805 (``mark``, ``scan``, ``finals``, ``freebits`` y ``noscan``), se utilizan 40
1806 KiB de memoria para conjuntos de bits (un 4% de *desperdicio* si, por
1807 ejemplo, ese *pool* estuviera destinado por completo a albergar un solo
1808 objeto grande; lo que equivaldría al 2560 objetos de 16 bytes
1809 desperdiciados en bits inutilizados).
1811 Repetición de código
1812 Hay algunos fragmentos de código repetidos innecesariamente. Por ejemplo en
1813 varios lugares se utilizan arreglos de tamaño variable que se implementan
1814 repetidas veces (en general como un puntero al inicio del arreglo más el
1815 tamaño actual del arreglo más el tamaño de la memoria total asignada
1816 actualmente). Esto es propenso a errores y difícil de mantener.
1819 El recolector actual utiliza las señales del sistema operativo ``SIGUSR1``
1820 y ``SIGUSR2`` para pausar y reanudar los hilos respectivamente. Esto
1821 puede traer inconvenientes a usuarios que desean utilizar estas
1822 señales en sus programas (o peor aún, si interactúan con bibliotecas
1823 de C que hacen uso de estas señales) [NGD5821]_.
1826 Si bien esto se mencionó como algo bueno del recolector actual, es un
1827 compromiso entre tiempo y espacio, y puede ser interesante analizar otros
1828 métodos para evitar la recursión que no requieran tantas pasadas sobre el
1835 Análisis de viabilidad
1836 ----------------------------------------------------------------------------
1838 Ya conociendo el lenguaje de programación D_ (con sus necesidades
1839 particulares), el estado del arte en recolección de basura y el recolector
1840 actual de D_ es posible evaluar la viabilidad de los distintos algoritmos
1841 vistos en el capítulo :ref:`gc`. Se recuerda que dentro del análisis de
1842 viabilidad de considera de gran importancia la viabilidad social y política de
1843 la mejora, es decir, se presta particular atención en encontrar una mejora que
1844 tenga una buena probabilidad de ser aceptada por la comunidad de D_.
1847 .. _dgc_via_classic:
1850 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1852 En esta sección se presenta un análisis de los :ref:`algoritmos clásicos
1853 <gc_classic>`, de forma de poder analizar a grandes rasgos las principales
1854 familias para ir determinando la dirección principal de la solución.
1859 Conteo de referencias
1860 ^^^^^^^^^^^^^^^^^^^^^
1861 Ya se ha propuesto en el pasado la utilización de conteo de referencias en D_
1862 pero no se ha demostrado un interés real, más allá de soluciones en
1863 bibliotecas [NGD38689]_. Las razones para no utilizar conteo de referencia son
1864 más o menos las mismas que las desventajas mencionadas en la sección
1865 :ref:`gc_rc` (en el capítulo :ref:`gc`), siendo la principal la incapacidad de
1866 recolectar ciclos. Sin embargo hay otras razones importantes.
1868 Una de ellas es la inter-operatividad con C. El utilizar un contador de
1869 referencias requiere la manipulación del contador por parte del código C con
1870 el que se interactúe. Si bien este problema ya está presente si código
1871 C guarda en su *headp* un puntero a un objeto almacenado en el *heap* del
1872 recolector de D_, esto es poco común. Sin embargo, mientras que una función de
1873 C se está ejecutando, es extremadamente común que pueda almacenar en el
1874 *stack* una referencia a un objeto de D_ y en ese caso el recolector actual
1875 puede manejarlo (mientras la función de C esté corriendo en un hilo creado por
1876 D_). Sin embargo al usar un conteo de referencias esto es más problemático, ya
1877 que no se mantiene la invariante del algoritmo si no son actualizados siempre
1880 Otro problema es que al liberarse una celda, existe la posibilidad de tener
1881 que liberar todo el sub-grafo conectado a ésta. Cuando este sub-grafo es
1882 grande, se puede observar una gran pausa.
1884 Si bien estas razones son suficientes como para considerar que el conteo de
1885 referencias no es un algoritmo que sea viable en D_, hay muchas técnicas
1886 y optimizaciones para minimizarlas (como liberación perezosa, conteo de
1887 referencias pospuesto, etc. [JOLI96]_). Sin embargo hay otra razón importante
1888 que descarta esta familia de algoritmos ya que todas las variaciones de conteo
1889 de referencias implican, en mayor o menor medida, el entrelazado del trabajo
1890 del recolector con el del *mutator*. Si bien esta es una característica en
1891 general muy deseable (porque hace que el recolector sea :ref:`incremental
1892 <gc_inc>`), en D_ no lo es porque tiene como requerimiento no hacer pagar el
1893 precio de cosas que no se usan. En D_ debe ser posible no utilizar el
1894 recolector de basura y, al no hacerlo, no tener ningún tipo de trabajo extra
1895 asociado a éste. De usarse conteo de referencias esto no sería posible.
1897 Si bien este requerimiento puede ser discutible técnicamente, hay una gran
1898 resistencia social y política ante cualquier tipo de recolector que imponga
1899 una penalización de rendimiento a alguien que no quiera usarlo [NGD38689]_.
1900 Además requiere un cambio complejo y profundo en el compilador, siendo éste
1901 uno de los eslabones con mayor resistencia a introducir cambios.
1903 Por lo tanto se concluye que el conteo de referencias no es un algoritmo
1904 viable para este trabajo.
1907 .. _dgc_via_mark_sweep:
1911 El marcado y barrido es un algoritmo evidentemente viable debido a que es la
1912 base del algoritmo del recolector de basura actual.
1914 En general en la comunidad de D_ no hay mayores críticas al marcado y barrido
1915 en sí, si no más bien a problemas asociados a la implementación actual,
1916 principalmente a las grandes pausas o la falta de :ref:`precisión
1917 <gc_conserv>` [NGD54084]_ [NGL13744]_ [NGD44607]_ [NGD29291]_ [NGD87831]_
1918 [NGD87831]_ [NGL3937]_ [NGD22968]_ [NGA15246]_ [NGD5622]_ [NGD2547]_
1921 Esta familia de algoritmos se adapta bien a los requerimientos principales de
1922 D_ en cuanto a recolección de basura (ver :ref:`dgc_needs`), por ejemplo
1923 permite recolectar de forma conservativa, no impone un *overhead* a menos que
1924 se utilice el recolector, permite liberar memoria manualmente, se adapta de
1925 forma simple para soportar punteros *interiores* y permite finalizar objetos
1926 (con las limitaciones mencionadas en :ref:`dgc_prob_final`).
1928 Sin embargo muchas de las limitaciones del recolector actual (ver
1929 :ref:`dgc_bad`), no son inherentes al marcado y barrido, por lo que aún
1930 conservando la base del algoritmo, es posible realizar una cantidad de mejoras
1933 Una de las principales mejoras que pueden realizarse es hacer al recolector
1934 :ref:`concurrente <gc_concurrent>` y más :ref:`preciso <gc_conserv>`. Estas
1935 dos mejoras solamente alcanzarían para mejorar de forma notable el tiempo de
1936 pausa en las recolecciones y la cantidad de memoria retenida debido a *falsos
1939 Más adelante veremos detalles sobre algunos de estos aspectos y sobre algunos
1940 algoritmos particulares que permiten hacer concurrente al recolector actual.
1943 Copia de semi-espacio
1944 ^^^^^^^^^^^^^^^^^^^^^
1945 La copia de semi-espacio, al igual que cualquier otro tipo de recolector con
1946 movimiento, requiere (en la mayoría de los casos) disponer de una
1947 :ref:`precisión <gc_conserv>` casi completa. Las celdas para las cuales hay
1948 alguna referencia que no es precisa no pueden ser movidas, ya que al no estar
1949 seguros que la referencia sea tal, ésta no puede ser actualizada con la
1950 dirección de la nueva ubicación de la celda movida porque de no ser una
1951 referencia se estarían alterando datos del usuario, corrompiéndolos.
1953 Es por esto que si el recolector no es mayormente preciso, las celdas que
1954 pueden ser movidas son muy pocas y, por lo tanto, se pierden las principales
1955 ventajas de esta familia de recolectores (como la capacidad de asignar nueva
1956 memoria mediante *pointer bump allocation*).
1958 Este aumento de precisión, sin embargo, es bastante realizable. Es posible, en
1959 teoría, hacer que al menos el *heap* sea preciso, aunque es discutible si en
1960 la práctica es aceptable el *overhead* en espacio necesario para almacenar la
1961 información del tipo de una celda. Esto se analiza en más detalle al evaluar
1962 la recolección precisa en la siguiente sección.
1964 Si bien las principales herramientas para que sea viable un recolector por
1965 copia de semi-espacio están disponibles en D_ (como la posibilidad de hacer
1966 *pinning* the celdas o el potencial incremento de precisión), este lenguaje
1967 nunca va a poder proveer precisión total, haciendo que no sea posible
1968 implementar un recolector por copia de semi-espacio puro. Siempre habrá que
1969 disponer un esquema híbrido para poder manejar las celdas que no puedan
1970 moverse, incrementado mucho la complejidad del recolector.
1972 Si bien un esquema híbrido es algo técnicamente posible, nuevamente la
1973 resistencia social a un cambio de esta envergadura es de importancia
1974 suficiente como para inclinarse por una solución menos drástica.
1979 Principales categorías del estado del arte
1980 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1982 En esta sección se realiza un análisis de la viabilidad de las principales
1983 categorías de recolectores según se presentaron en la sección :ref:`gc_art`.
1985 Recolección directa / indirecta
1986 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1987 Como se ha visto al analizar el conteo de referencias, lo más apropiado para
1988 D_ pareciera ser continuar con el esquema de recolección indirecta, de forma
1989 tal de que el precio de la recolección solo deba ser pagado cuando el
1990 *mutator* realmente necesita del recolector. Es por esto que no parece ser una
1991 opción viable introducir recolección directa en este trabajo.
1994 Recolección incremental
1995 ^^^^^^^^^^^^^^^^^^^^^^^
1996 La recolección incremental puede ser beneficiosa para D_, dado que puede
1997 servir para disminuir el tiempo de pausa del recolector. Sin embargo, en
1998 general es necesario instrumentar el *mutator* para reportar cambios en el
1999 grafo del conectividad al recolector. Además puede contar con los mismos
2000 problemas que la recolección directa, puede hacer que el usuario tenga que
2001 pagar el precio de la recolección, incluso cuando no la necesita, si por cada
2002 asignación el recolector realiza parte de una recolección que no fue
2005 Recolección concurrente / paralela / *stop-the-world*
2006 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2007 El recolector actual es *stop-the-world*, sin embargo esta es una de las
2008 principales críticas que tiene. El recolector se podría ver beneficiado de
2009 recolección paralela, tanto para realizar la recolección más velozmente en
2010 ambientes *multi-core*, como para disminuir el tiempo de pausa, un factor muy
2011 importante para programas que necesiten tener baja latencia, como programas
2014 En general los recolectores concurrentes necesitan también instrumentar el
2015 *mutator* para reportar cambios en el grafo de conectividad al recolector,
2016 como sucede con la recolección directa o incremental, sin embargo hay
2017 algoritmos que no tienen este requerimiento, utilizando servicios del sistema
2018 operativo para tener una *fotografía* de la memoria para que la fase de
2019 marcado pueda realizarse sin perturbar al *mutator* ni requerir de su
2020 cooperación [RODR97]_. Este tipo de algoritmos serían un buen candidato para
2021 D_, dado que requiere pocos cambios y es transparente al *mutator*.
2024 Recolección conservativa / precisa
2025 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2026 Si bien D_ puede proveer al recolector de basura información de tipos para los
2027 objetos almacenados en el *heap*, todo recolector para D_ deberá soportar
2028 cierto grado de recolección conservativa (ver :ref:`gc_conserv`), debido a las
2031 * Si bien D_ podría incorporar información de tipos para el *stack*
2032 (utilizando, por ejemplo, la técnica de *shadow stack* [HEND02]_), para
2033 poder interactuar con C/C++, el recolector debe poder interpretar los *stack
2034 frames* [#dgcstackframe]_ de estos lenguajes, que no disponen de información
2037 * Los registros del procesador tienen un problema similar, con la diferencia
2038 de que el costo de implementar algo similar a *shadow stack* para los
2039 registros sería impracticable, más allá de que exista la misma limitación
2040 que con el *stack* para poder interactuar con C/C++.
2042 * D_ soporta uniones (ver :ref:`d_low_level`). Para una unión es imposible
2043 determinar si un campo es un puntero o no. Por ejemplo::
2050 Aquí el recolector no puede saber nunca si el valor almacenado será un
2051 ``size_t`` o un ``void*``, por lo tanto deberá tratar **siempre** esa
2052 palabra de forma conservativa (es decir, interpretarla como un *posible*
2053 puntero). Este requerimiento puede ser relajado si el usuario proveyera
2054 alguna forma de determinar que tipo está almacenando la unión en un
2055 determinado momento. Sin embargo el costo de pedir al usuario este tipo de
2056 restricción puede ser muy alto.
2058 Durante el desarrollo de este trabajo se encontra un trabajo relacionado
2059 avanzando en este sentido, que agrega precisión al marcado del *heap*. David
2060 Simcha comienza explorando la posibilidad de agregar precisión parcial al
2061 recolector, generando información sobre la ubicación de los punteros para cada
2062 tipo [DBZ3463]_. Su trabajo se limita a una implementación a nivel biblioteca
2063 de usuario y sobre `D 2.0`_. Desafortunadamente su trabajo pasa desapercibido
2066 Sin embargo un tiempo después Vincent Lang (mejor conocido como *wm4* en la
2067 comunidad de D_), retoma este trabajo, pero modificando el compilador DMD_
2068 y trabajando con `D 1.0`_ y Tango_. Es por esto que el aumento de precisión
2069 parece ser un área fértil para este trabajo, en particular si se colabora con
2070 el trabajo realizado por David y Vincent.
2072 .. [#dgcstackframe] Un *stack frame* (*marco de la pila* en castellano),
2073 también conocido como *activation record* (o *registro de activación* en
2074 castellano) es una estructura de datos dependiente de la arquitectura que
2075 contiene información del estado de una función, incluyendo, por ejemplo,
2076 sus variables locales, parámetros y dirección de retorno.
2079 Recolección con movimiento de celdas
2080 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2081 Esta posibilidad ya se ha discutido al analizar la posibilidad de utilizar
2082 recolección con copia de semi-espacios. El trabajo mencionado en la sub-sección
2083 anterior agrega información suficiente como poder diferenciar que celdas se
2084 pueden mover y cuales no, sin embargo queda como incógnita qué proporción de
2085 celdas deben permanecer inmovilizadas como para evaluar si un cambio tan
2086 grande puede rendir frutos o no.
2088 A priori, pareciera que la relación cantidad y complejidad de cambios sobre
2089 beneficios potenciales no fuera muy favorable a esta mejora.
2092 Lista de libres / *pointer bump allocation*
2093 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2094 Como consecuencia de los puntos anteriores, no es técnicamente posible
2095 realizar *pointer bump allocation* pura en D_. Al haber objetos *pinned*,
2096 siempre es necesario o bien contar con una lista de libres, o detectar
2097 *huecos* en un esquema de *pointer bump allocation*. Es por esto que parece
2098 ser más viable conservar el esquema de listas de libres.
2100 Esta mejora también entra en la categoría de opciones viables pero cuya
2101 complejidad no parece valer la pena dada la limitada utilidad que se espera
2102 dadas las particulares características de D_ en cuanto a precisión de
2103 información de tipos de *stack*, uniones, etc.
2106 Recolección por particiones / generacional
2107 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2108 Una vez más la recolección por particiones, en particular la generacional,
2109 requiere de la instrumentación del *mutator* para comunicar cambios en el
2110 grafo de conectividad al recolector, por lo que es poco viable. Aunque existen
2111 algoritmos que no necesitan este tipo de comunicación dado que está
2112 garantizado que no existan conexiones entre celdas de las distintas
2113 particiones, requiere grandes cambios en el compilador y realizar análisis
2114 estático bastante complejo [HIRZ03]_. Además al ser D_ un lenguaje de bajo
2115 nivel, es muy difícil garantizar que estas conexiones inter-particiones no
2116 puedan existir realmente; y de hacerlo, podría ser demasiado restrictivo.
2119 .. include:: links.rst
2121 .. vim: set ts=3 sts=3 sw=3 et tw=78 spelllang=es :
projects / z.facultad / 75.00 / informe.git / blob