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 .. _ref_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 .. _ref_dgc_actual:
  27
  28 Recolector de basura actual de D
  29 ----------------------------------------------------------------------------
  30
  31 TODO
  32
  33
  34
  35 Diseño
  36 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  37
  38 .. Acá iría básicamente lo que escribí en el blog sobre la implmentación
  39    actual
  40
  41 TODO
  42
  43
  44
  45 Implementación
  46 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  47
  48 .. Acá diría por qué hay que reescribirlo para usar lo que está
  49
  50 TODO
  51
  52
  53
  54 Problemas y limitaciones
  55 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  56
  57 TODO
  58
  59
  60
  61
  62 Como se ha visto, D_ es un lenguaje de programación muy completo,
  63 pero aún tiene algunos aspectos inconclusos. Su recolector de basura
  64 está en un estado de evolución muy temprana. Se trata de un marcado y
  65 barrido (*mark and sweep*) conservativo que, en ciertas circunstancias,
  66 no se comporta como es debido, ya que revisa toda la memoria del programa
  67 en busca de referencias a objetos en el *heap* (en vez de revisar sólo
  68 las partes que almacenan punteros). Esto produce que, en ciertos casos,
  69 por ejemplo al almacenar arreglos de número o *strings* en la pila, el
  70 recolector de basura se encuentre con *falsos positivos*, pensando que
  71 un área del *heap* está siendo utilizada cuando en realidad el puntero
  72 que hacía referencia a ésta no era tal. Este efecto puede llevar a la
  73 pérdida de memoria masiva, llegando al límite de que eventualmente
  74 el sistema operativo tenga que matar al programa por falta de memoria
  75 [DNG46407]_. Aún cuando el programa no tenga estos problemas de por sí,
  76 por usar datos que no pueden ser confundidos con direcciones de memoria,
  77 este problema podría ser explotado por ataques de seguridad, inyectando
  78 valores que sí sean punteros válidos y provocando el efecto antes
  79 mencionado que deriva en la terminación abrupta del programa [DNG35364]_.
  80 Finalmente, a estos problemas se suman los problemas de *performance*
  81 [DNG43991]_.
  82
  83 Es difícil que D_ pueda ser un lenguaje de programación exitoso si
  84 no provee un recolector de basura eficiente y que realmente evite la
  85 pérdida masiva de memoria. Por otro lado, D_ podría atraer a una base de
  86 usuarios mucho más amplia, si la gama de estrategias de recolección es
  87 más amplia, pudiendo lograr adaptarse a más casos de uso sin llegar al
  88 límite de tener que caer en el manejo explícito de memoria y perder por
  89 completo las ventajas de la recolección de basura (con la consecuencia
  90 ya mencionada de que el manejo de memoria tenga que pasar a ser parte
  91 de las interfaces y la complejidad que esto agrega al diseño -y uso-
  92 de una biblioteca).
  93
  94
  95
  96 Soluciones Propuestas
  97
  98 Para poder implementar un recolector de basura no conservativo es
  99 necesario disponer de un soporte de reflexión (en tiempo de compilación
 100 [DNG44607]_ y de ejecución [DNG29291]_) bastante completo . De otra forma
 101 es imposible distinguir si un área de memoria de la pila es utilizada
 102 como un puntero o como un simple conjunto de datos. D_ provee algún
 103 grado de reflexión, pero muy limitado como para poder obtener este
 104 tipo de información. Ya hay un plan para agregar mayores capacidades
 105 de reflexibilidad [DNG6842]_, y un pequeño avance en este sentido en la
 106 `versión 1.001`_, pero con algunos problemas [DNG6890]_ [DNG6893]_.
 107
 108 .. _`versión 1.001`: http://www.digitalmars.com/d/changelog.html#new1_001
 109
 110 Se han propuesto otros métodos e implementaciones de recolector de basura,
 111 por ejemplo colectores con movimiento (*moving collectors*) [DNG42557]_
 112 y conteo de referencias [DNG38689]_. Pero D_ es un lenguaje muy particular
 113 en cuanto a la recolección de basura (al permitir :ref:d_low_level hay
 114 muchas consideraciones a las que otros lenguajes no deben enfrentarse) y no
 115 es sencillo pensar en otras implementaciones sin hacer modificaciones de
 116 base al lenguaje.
 117
 118
 119
 120 Problemas para Implementar Colectores con Movimiento
 121
 122 El principal problema es la capacidad de D_ de manipular punteros y
 123 otras estructuras de bajo nivel, como uniones. O incluso la capacidad
 124 de interactuar con C. Al mover un objeto de un área de memoria a otro,
 125 es necesario actualizar todos los punteros que apuntan a éste. En D_
 126 esta tarea no es trivial [DNG42564]_
 127
 128
 129
 130 Problemas para Implementar Conteo de Referencias
 131
 132 Este tipo de recolectores reparten la carga de la recolección de forma
 133 uniforme a lo largo (y a la par) de la ejecución del programa. El
 134 problema principal para implementar este tipo de recolección es
 135 la necesidad de soporte en el compilador (cada asignación debe ser
 136 acompañada por el incremento/decremento de contadores de referencia), a
 137 menos que se implemente en una biblioteca. Por otro lado, características
 138 como el rebanado de arreglos (ver :ref:d_high_level) son
 139 difíciles de proveer con el conteo de referencias, entre otros problemas
 140 [DNG38704]_.
 141
 142
 143 .. include:: links.rst
 144
 145 .. vim: set ts=3 sts=3 sw=3 et tw=78 :