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
575 Detalles de implementación
576 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
578 .. Acá diría por qué hay que reescribirlo para usar lo que está
584 Problemas y limitaciones
585 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
592 Como se ha visto, D_ es un lenguaje de programación muy completo, pero aún
593 tiene algunos aspectos inconclusos. Su recolector de basura está en un estado
594 de evolución muy temprana. Se trata de un marcado y barrido (*mark and sweep*)
595 conservativo que, en ciertas circunstancias, no se comporta como es debido, ya
596 que revisa toda la memoria del programa en busca de referencias a objetos en
597 el *heap* (en vez de revisar sólo las partes que almacenan punteros). Esto
598 produce que, en ciertos casos, por ejemplo al almacenar arreglos de número
599 o *strings* en la pila, el recolector de basura se encuentre con *falsos
600 positivos*, pensando que un área del *heap* está siendo utilizada cuando en
601 realidad el puntero que hacía referencia a ésta no era tal. Este efecto puede
602 llevar a la pérdida de memoria masiva, llegando al límite de que eventualmente
603 el sistema operativo tenga que matar al programa por falta de memoria
604 [DNG46407]_. Aún cuando el programa no tenga estos problemas de por sí, por
605 usar datos que no pueden ser confundidos con direcciones de memoria, este
606 problema podría ser explotado por ataques de seguridad, inyectando valores que
607 sí sean punteros válidos y provocando el efecto antes mencionado que deriva en
608 la terminación abrupta del programa [DNG35364]_. Finalmente, a estos problemas
609 se suman los problemas de *performance* [DNG43991]_.
611 Es difícil que D_ pueda ser un lenguaje de programación exitoso si no provee un
612 recolector de basura eficiente y que realmente evite la pérdida masiva de
613 memoria. Por otro lado, D_ podría atraer a una base de usuarios mucho más
614 amplia, si la gama de estrategias de recolección es más amplia, pudiendo lograr
615 adaptarse a más casos de uso sin llegar al límite de tener que caer en el
616 manejo explícito de memoria y perder por completo las ventajas de la
617 recolección de basura (con la consecuencia ya mencionada de que el manejo de
618 memoria tenga que pasar a ser parte de las interfaces y la complejidad que esto
619 agrega al diseño -y uso- de una biblioteca).
623 Soluciones Propuestas
625 Para poder implementar un recolector de basura no conservativo es necesario
626 disponer de un soporte de reflexión (en tiempo de compilación [DNG44607]_ y de
627 ejecución [DNG29291]_) bastante completo . De otra forma es imposible
628 distinguir si un área de memoria de la pila es utilizada como un puntero o como
629 un simple conjunto de datos. D_ provee algún grado de reflexión, pero muy
630 limitado como para poder obtener este tipo de información. Ya hay un plan para
631 agregar mayores capacidades de reflexibilidad [DNG6842]_, y un pequeño avance
632 en este sentido en la `versión 1.001`_, pero con algunos problemas [DNG6890]_
635 .. _`versión 1.001`: http://www.digitalmars.com/d/changelog.html#new1_001
637 Se han propuesto otros métodos e implementaciones de recolector de basura, por
638 ejemplo colectores con movimiento (*moving collectors*) [DNG42557]_ y conteo de
639 referencias [DNG38689]_. Pero D_ es un lenguaje muy particular en cuanto a la
640 recolección de basura (al permitir :ref:d_low_level hay muchas consideraciones
641 a las que otros lenguajes no deben enfrentarse) y no es sencillo pensar en
642 otras implementaciones sin hacer modificaciones de base al lenguaje.
646 Problemas para Implementar Colectores con Movimiento
648 El principal problema es la capacidad de D_ de manipular punteros y otras
649 estructuras de bajo nivel, como uniones. O incluso la capacidad de interactuar
650 con C. Al mover un objeto de un área de memoria a otro, es necesario actualizar
651 todos los punteros que apuntan a éste. En D_ esta tarea no es trivial
656 Problemas para Implementar Conteo de Referencias
658 Este tipo de recolectores reparten la carga de la recolección de forma uniforme
659 a lo largo (y a la par) de la ejecución del programa. El problema principal
660 para implementar este tipo de recolección es la necesidad de soporte en el
661 compilador (cada asignación debe ser acompañada por el incremento/decremento de
662 contadores de referencia), a menos que se implemente en una biblioteca. Por
663 otro lado, características como el rebanado de arreglos (ver :ref:d_high_level)
664 son difíciles de proveer con el conteo de referencias, entre otros problemas
668 .. include:: links.rst
670 .. vim: set ts=3 sts=3 sw=3 et tw=78 :
projects / z.facultad / 75.00 / informe.git / blob