source/dgc.rst

   1
   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
   8
   9
  10 .. _dgc:
  11
  12 Recolección de basura en D
  13 ============================================================================
  14
  15 TODO
  16
  17
  18
  19 Dificultades para recolectar basura en D
  20 ----------------------------------------------------------------------------
  21
  22 TODO
  23
  24
  25
  26 .. _dgc_actual:
  27
  28 Recolector de basura actual de D
  29 ----------------------------------------------------------------------------
  30
  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
  34 formas de mejorarlo.
  35
  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).
  42
  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.
  50
  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>`.
  64
  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.
  69
  70
  71 .. _dgc_org:
  72
  73 Organización del *heap*
  74 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  75
  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
  89 dicho objeto.
  90
  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
  93    página).
  94
  95 .. fig:: fig:dgc-org
  96
  97    Organización del *heap* del recolector de basura actual de D.
  98
  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.
 103
 104    .. aafig::
 105       :scale: 1.4
 106
 107       +----------------------------------------------------------------------+
 108       |                                 Heap                                 |
 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       +----------------------------------------------------------------------+
 152
 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.
 160
 161 .. fig:: fig:dgc-free-list
 162
 163    Ejemplo de listas de libres.
 164
 165    .. digraph:: dgc_free_list
 166
 167       margin  = 0;
 168       rankdir = LR;
 169       ratio   = fill;
 170       size    = "4.6,3.6";
 171       node [ shape = record, width = 0, height = 0 ];
 172
 173       subgraph cluster_heap {
 174          style = solid;
 175          color = black;
 176
 177          free [ label = "Libres|<p16> 16|<p32> 32|<p64> 64|<p128> 128|<p256> 256|<p512> 512|<p1024> 1024|<p2048> 2048" ];
 178
 179          free:p16 -> b1 -> b2 -> b3;
 180          free:p32 -> b4 -> b5 -> b6 -> b7 -> b8;
 181          // free:p64 is empty
 182          free:p128 -> b9;
 183          free:p256 -> b10 -> b11;
 184          free:p512 -> b12;
 185          free:p1024 -> b13 -> b14;
 186          free:p2048 -> b15 -> b16 -> b17;
 187       }
 188
 189
 190 Atributos de *pool*
 191 ^^^^^^^^^^^^^^^^^^^
 192 Cada *pool* tiene la siguiente información asociada:
 193
 194 *number_of_pages*:
 195    cantidad de páginas que tiene. Esta cantidad es fija en toda la vida de un
 196    *pool*.
 197
 198 *pages*:
 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).
 201
 202
 203 Atributos de página
 204 ^^^^^^^^^^^^^^^^^^^
 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.
 207
 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:
 212
 213 ``FREE``:
 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).
 218
 219 ``CONTINUATION``:
 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
 222    grandes.
 223
 224 Las páginas con esto tamaños de bloque especiales (conceptualmente) no
 225 contienen bloques.
 226
 227
 228 Atributos de bloque
 229 ^^^^^^^^^^^^^^^^^^^
 230 Cada bloque tiene asociados varios atributos:
 231
 232 *mark*:
 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>`).
 236
 237 *scan*:
 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>`).
 241
 242 *free*:
 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*).
 248
 249 *final*:
 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*).
 252
 253 *noscan*:
 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*).
 256
 257
 258 Objetos grandes
 259 ^^^^^^^^^^^^^^^
 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).
 266
 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
 270 tamaño determinado.
 271
 272
 273
 274 .. _dgc_algo:
 275
 276 Algoritmos del recolector
 277 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 278
 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`.
 282
 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.
 290
 291
 292 .. _dgc_algo_collect:
 293
 294 Recolección
 295 ^^^^^^^^^^^
 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>`::
 298
 299    function collect() is
 300       mark_phase()
 301       sweep_phase()
 302
 303
 304 .. _dgc_algo_mark:
 305
 306 Fase de marcado
 307 ^^^^^^^^^^^^^^^
 308 Esta fase consiste de varios pasos, que pueden resumirse en el siguiente
 309 algoritmo::
 310
 311    function mark_phase() is
 312       more_to_scan = false
 313       stop_the_world()
 314       clear_mark_scan_bits()
 315       mark_free_lists()
 316       mark_static_data()
 317       push_registers_into_stack()
 318       mark_stacks()
 319       mark_user_roots()
 320       mark_heap()
 321       start_the_world()
 322
 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.
 327
 328 Las funciones ``stop_the_world()`` y ``start_the_world()`` sencillamente
 329 pausan y reanudan todos los hilos respectivamente::
 330
 331    function stop_the_world() is
 332       foreach thread in threads
 333          thread.pause()
 334
 335    function start_the_world() is
 336       foreach thread in threads
 337          thread.resume()
 338
 339 La función ``clear_mark_scan_bits()`` se encarga de resetear todos los
 340 atributos *mark* y *scan* de cada bloque del *heap*::
 341
 342    function clear_mark_scan_bits() is
 343       foreach pool in heap
 344          foreach page in pool
 345             foreach block in page
 346                block.mark = false
 347                block.scan = false
 348
 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)::
 355
 356    function mark_free_lists() is
 357       foreach free_list in heap
 358          foreach block in free_list
 359             block.mark = true
 360             block.free = true
 361
 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.
 367
 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)::
 372
 373    function mark_static_data() is
 374       foreach word in static_data
 375          pointer = cast(void*) word
 376          mark(pointer)
 377
 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::
 380
 381    function push_registers_into_stack() is
 382       foreach register in registers
 383          push(register)
 384
 385 Una vez hecho esto, basta marcar (de forma conservativa) los *stacks* de todos
 386 los threads para terminar de marcar el *root set*::
 387
 388    function mark_stacks() is
 389       foreach thread in threads
 390          foreach word in thread.stack
 391             pointer = cast(void*) word
 392             mark(pointer)
 393
 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::
 401
 402    function mark_user_roots() is
 403       foreach pointer in user_roots
 404          mark(pointer)
 405
 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*)::
 409
 410    function mark(pointer) is
 411       [pool, page, block] = find_block(pointer)
 412       if block is not null and block.mark is false
 413          block.mark = true
 414          if block.noscan is false
 415             block.scan = true
 416             more_to_scan = true
 417
 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)::
 423
 424    function mark_heap() is
 425       while more_to_scan
 426          more_to_scan = false
 427          foreach pool in heap
 428             foreach page in pool
 429                if page.block_size <= PAGE // saltea FREE y CONTINUATION
 430                   foreach block in page
 431                      if block.scan is true
 432                         block.scan = false
 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
 438                                  mark(pointer)
 439                         else // objeto pequeño
 440                            foreach word in block
 441                               pointer = cast(void*) word
 442                               mark(pointer)
 443
 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``).
 454
 455 A continuación se presenta la implementación de las funciones suplementarias
 456 utilizadas en la fase de marcado::
 457
 458    function find_big_object_end(pool, page) is
 459       pool_end = cast(byte*) pool.pages + (PAGE_SIZE * pool.number_of_pages)
 460       do
 461          page = cast(byte*) page + PAGE_SIZE
 462       while page.block_size is CONTINUATION and page < pool_end
 463       return page
 464
 465    function find_block(pointer) is
 466       foreach pool in heap
 467          foreach page in pool
 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]
 480
 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
 483 *interiores*.
 484
 485
 486 .. _dgc_algo_sweep:
 487
 488 Fase de barrido
 489 ^^^^^^^^^^^^^^^
 490 Esta fase es considerablemente más sencilla que el marcado; el algoritmo puede
 491 dividirse en dos pasos básicos::
 492
 493    function sweep_phase() is
 494       sweep()
 495       rebuild_free_lists()
 496
 497 El barrido se realiza con una pasada por sobre todo el heap
 498
 499
 500
 501 .. _dgc_impl:
 502
 503 Detalles de implementación
 504 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 505
 506 .. Acá diría por qué hay que reescribirlo para usar lo que está
 507
 508 TODO
 509
 510
 511
 512 Problemas y limitaciones
 513 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 514
 515 TODO
 516
 517
 518
 519
 520 Como se ha visto, D_ es un lenguaje de programación muy completo, pero aún
 521 tiene algunos aspectos inconclusos. Su recolector de basura está en un estado
 522 de evolución muy temprana. Se trata de un marcado y barrido (*mark and sweep*)
 523 conservativo que, en ciertas circunstancias, no se comporta como es debido, ya
 524 que revisa toda la memoria del programa en busca de referencias a objetos en
 525 el *heap* (en vez de revisar sólo las partes que almacenan punteros). Esto
 526 produce que, en ciertos casos, por ejemplo al almacenar arreglos de número
 527 o *strings* en la pila, el recolector de basura se encuentre con *falsos
 528 positivos*, pensando que un área del *heap* está siendo utilizada cuando en
 529 realidad el puntero que hacía referencia a ésta no era tal. Este efecto puede
 530 llevar a la pérdida de memoria masiva, llegando al límite de que eventualmente
 531 el sistema operativo tenga que matar al programa por falta de memoria
 532 [DNG46407]_. Aún cuando el programa no tenga estos problemas de por sí, por
 533 usar datos que no pueden ser confundidos con direcciones de memoria, este
 534 problema podría ser explotado por ataques de seguridad, inyectando valores que
 535 sí sean punteros válidos y provocando el efecto antes mencionado que deriva en
 536 la terminación abrupta del programa [DNG35364]_.  Finalmente, a estos problemas
 537 se suman los problemas de *performance* [DNG43991]_.
 538
 539 Es difícil que D_ pueda ser un lenguaje de programación exitoso si no provee un
 540 recolector de basura eficiente y que realmente evite la pérdida masiva de
 541 memoria. Por otro lado, D_ podría atraer a una base de usuarios mucho más
 542 amplia, si la gama de estrategias de recolección es más amplia, pudiendo lograr
 543 adaptarse a más casos de uso sin llegar al límite de tener que caer en el
 544 manejo explícito de memoria y perder por completo las ventajas de la
 545 recolección de basura (con la consecuencia ya mencionada de que el manejo de
 546 memoria tenga que pasar a ser parte de las interfaces y la complejidad que esto
 547 agrega al diseño -y uso- de una biblioteca).
 548
 549
 550
 551 Soluciones Propuestas
 552
 553 Para poder implementar un recolector de basura no conservativo es necesario
 554 disponer de un soporte de reflexión (en tiempo de compilación [DNG44607]_ y de
 555 ejecución [DNG29291]_) bastante completo . De otra forma es imposible
 556 distinguir si un área de memoria de la pila es utilizada como un puntero o como
 557 un simple conjunto de datos. D_ provee algún grado de reflexión, pero muy
 558 limitado como para poder obtener este tipo de información. Ya hay un plan para
 559 agregar mayores capacidades de reflexibilidad [DNG6842]_, y un pequeño avance
 560 en este sentido en la `versión 1.001`_, pero con algunos problemas [DNG6890]_
 561 [DNG6893]_.
 562
 563 .. _`versión 1.001`: http://www.digitalmars.com/d/changelog.html#new1_001
 564
 565 Se han propuesto otros métodos e implementaciones de recolector de basura, por
 566 ejemplo colectores con movimiento (*moving collectors*) [DNG42557]_ y conteo de
 567 referencias [DNG38689]_. Pero D_ es un lenguaje muy particular en cuanto a la
 568 recolección de basura (al permitir :ref:d_low_level hay muchas consideraciones
 569 a las que otros lenguajes no deben enfrentarse) y no es sencillo pensar en
 570 otras implementaciones sin hacer modificaciones de base al lenguaje.
 571
 572
 573
 574 Problemas para Implementar Colectores con Movimiento
 575
 576 El principal problema es la capacidad de D_ de manipular punteros y otras
 577 estructuras de bajo nivel, como uniones. O incluso la capacidad de interactuar
 578 con C. Al mover un objeto de un área de memoria a otro, es necesario actualizar
 579 todos los punteros que apuntan a éste. En D_ esta tarea no es trivial
 580 [DNG42564]_
 581
 582
 583
 584 Problemas para Implementar Conteo de Referencias
 585
 586 Este tipo de recolectores reparten la carga de la recolección de forma uniforme
 587 a lo largo (y a la par) de la ejecución del programa. El problema principal
 588 para implementar este tipo de recolección es la necesidad de soporte en el
 589 compilador (cada asignación debe ser acompañada por el incremento/decremento de
 590 contadores de referencia), a menos que se implemente en una biblioteca. Por
 591 otro lado, características como el rebanado de arreglos (ver :ref:d_high_level)
 592 son difíciles de proveer con el conteo de referencias, entre otros problemas
 593 [DNG38704]_.
 594
 595
 596 .. include:: links.rst
 597
 598 .. vim: set ts=3 sts=3 sw=3 et tw=78 :