source/intro.rst

   1
   2 .. Introducción al trabajo, objetivos, alcance, limitaciones y organización
   3    del documento.
   4    ESTADO: TERMINADO
   5
   6
   7 .. _intro:
   8
   9 Introducción
  10 ============================================================================
  11
  12 La recolección de basura es una técnica que data de fines de los años '50,
  13 cuando `John McCarthy`_, creador de Lisp_, agregó a dicho lenguaje la
  14 capacidad de administrar la memoria automáticamente (utilizando conteo de
  15 referencias), entre muchos otros conceptos revolucionarios para la época que
  16 recién fueron explotados masivamente en lenguajes dinámicos más modernos como
  17 Perl_, Python_, Ruby_, etc. A partir de este momento, muchos lenguajes tomaron
  18 esta característica y hubo una gran cantidad de investigación al respecto,
  19 tomando particular importancia.
  20
  21 Nuevos algoritmos fueron desarrollados para atacar distintos problemas
  22 particulares y para mejorar la *performance*, que ha sido una inquietud
  23 incesante en la investigación de recolectores de basura. Sin embargo el
  24 lenguaje más masivo que ha adoptado un recolector de basura (al menos en el
  25 ámbito empresarial) fue Java_, con el cual la investigación sobre recolección
  26 de basura tomó un impulso extra. Probablemente el mayor desarrollo
  27 e investigación en cuanto a recolección de basura se siga dando para Java_,
  28 acotando tal vez un poco el alcance de estos avances dado que ese lenguaje
  29 tiene características muy particulares (*tipado* estático, corre sobre una
  30 máquina virtual muy rica en cuanto a información de tipos, etc.) no
  31 disponibles en otros lenguajes. Sin embargo los lenguajes funcionales y con
  32 *tipado* dinámico siguieron teniendo un nivel de investigación y desarrollo
  33 importante, dado que fueron concebidos en su mayoría con la recolección de
  34 basura como parte del diseño.
  35
  36 Probablemente los lenguajes en los cuales es más difícil aplicar los avances
  37 que se desprendieron de Java_ o de las otras categoría de lenguajes con más
  38 avances en recolección de basura sean los de más bajo nivel (como C y C++), en
  39 los cuales se da lo inverso en cuanto a disponibilidad de información en
  40 tiempo de ejecución, sumado a la permisividad de estos lenguajes para realizar
  41 manipulación de memoria directamente y trabajar a muy bajo nivel. De la mano
  42 de estos lenguajes apareció otra veta de investigación en lo que se denominó
  43 recolectores de basura *conservativos*.
  44
  45 Una categoría de lenguaje que ha quedado prácticamente vacante es un término
  46 intermedio entre los lenguajes de muy alto nivel (como Java_, Python_,
  47 Haskell_, etc.). El lenguaje de programación D_ está en esta categoría y,
  48 a pesar de haber sido diseñado con soporte de recolección de basura, al ser un
  49 lenguaje relativamente nuevo, ha tenido muy poco desarrollo en ese área. El
  50 lenguaje tiene todas las limitaciones de lenguajes de bajo nivel como C y C++
  51 pero esas limitaciones suelen estar más aisladas, y provee un poco más de
  52 información que puede ser aprovechada por un recolector de la que suelen
  53 proveer los demás lenguajes de estas características. Esto presenta una
  54 oportunidad única en cuanto a investigación y desarrollo de recolectores que
  55 se ajusten a estas características.
  56
  57
  58
  59 Objetivo
  60 ----------------------------------------------------------------------------
  61
  62 El objetivos de esta tesis es mejorar el recolector de basura de el lenguaje
  63 D_, investigando el estado del arte en recolección de basura y haciendo un
  64 análisis de viabilidad de los algoritmos principales para optar por el que
  65 mejor se ajuste a D_. Una parte muy importante de este análisis es participar
  66 de la comunidad del lenguaje y sus diseñadores para poder desarrollar una
  67 mejora que sea aceptada y pueda ser utilizada por el lenguaje. Por lo tanto el
  68 algoritmo o mejora que "mejor se ajuste a D_" estará supeditado en gran parte
  69 a los requerimientos más urgentes de los usuarios de D_.
  70
  71
  72
  73 Alcance
  74 ----------------------------------------------------------------------------
  75
  76 El alcance de este trabajo se limita a los siguientes puntos:
  77
  78 * Explorar los problemas del recolector de basura actual.
  79 * Evaluar cuales de estos problemas son de mayor importancia para la
  80   comunidad de usuarios de D_.
  81 * Analizar la viabilidad de algoritmos y optimizaciones para solucionar
  82   o minimizar el o los problemas de mayor importancia.
  83 * Implementar una solución o mejora en base al análisis elaborado.
  84 * Comparar mediante la utilización de un banco de pruebas (*benchmark*) la
  85   implementación con la actual y posiblemente con otras implementaciones
  86   relevantes a fin de cuantificarla.
  87 * Proveer todos los elementos necesarios para que la solución pueda ser
  88   adoptada por el lenguaje.
  89
  90
  91 Limitaciones
  92 ----------------------------------------------------------------------------
  93
  94 Dado que el lenguaje de programación D_ puede ser enlazado con código objeto
  95 C, y por lo tanto interactuar directamente con éste, podrán haber limitaciones
  96 en el recolector resultante con respecto a esto. En este trabajo se busca
  97 lograr un recolector que sea eficiente para casos en donde el código que
  98 interactúa con C esté bien aislado, por lo que estas porciones de código
  99 pueden quedar por fuera del recolector de basura o necesitar un manejo
 100 especial.
 101
 102
 103 Organización
 104 ----------------------------------------------------------------------------
 105
 106 Este trabajo se encuentra dividido en 7 cápitos que se describen
 107 a continuación:
 108
 109 1. :ref:`intro`: breve descripción del problema a tratar, presentando
 110    los objetivos y alcances del trabajo.
 111 2. :ref:`d_lang`: presenta las características principales del lenguaje,
 112    destacando aquellas de mayor relevancia para este trabajo.
 113 3. :ref:`gc`: presenta los algoritmos básicos de recolección de basura
 114    y describe el estado del arte.
 115 4. :ref:`dgc`: explica los problemas particulares que presenta el
 116    lenguaje para la recolección de basura, describe el diseño
 117    e implementación del recolector actual y presenta sus principales
 118    deficiencias.
 119 5. :ref:`analisis`: realiza un recorrido por los algoritmos presentados
 120    en :ref:`gc` analizando su viabilidad para aplicarse en D_.
 121 6. :ref:`solucion`: propone una solución a los problemas encontrados en
 122    :ref:`dgc` en base al análisis hecho en :ref:`analisis`.
 123 7. :ref:`conclusion`: describe los resultados del trabajo, proponiendo
 124    trabajos futuros y relacionados.
 125
 126
 127
 128 .. include:: links.rst
 129
 130 .. vim: set ts=3 sts=3 sw=3 et tw=78 :