source/intro.rst

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