From 13c8978d868a3949d3dbf47a2280e2625288f47a Mon Sep 17 00:00:00 2001
From: Leandro Lucarella <llucax@gmail.com>
Date: Fri, 19 Jun 2009 22:31:18 -0300
Subject: [PATCH] =?utf8?q?Agregar=20glosario=20de=20t=C3=A9rminos?=
MIME-Version: 1.0
Content-Type: text/plain; charset=utf8
Content-Transfer-Encoding: 8bit

---
 source/gc.rst       |   1 +
 source/glosario.rst | 515 ++++++++++++++++++++++++++++++++++++++++++++
 source/index.rst    |   1 +
 3 files changed, 517 insertions(+)
 create mode 100644 source/glosario.rst

diff --git a/source/gc.rst b/source/gc.rst
index ef01f69..515a860 100644
--- a/source/gc.rst
+++ b/source/gc.rst
@@ -95,6 +95,7 @@ errores.
 
 
 
+.. _gc_intro_basics:
 
 Conceptos básicos
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/source/glosario.rst b/source/glosario.rst
new file mode 100644
index 0000000..6f3eb1a
--- /dev/null
+++ b/source/glosario.rst
@@ -0,0 +1,515 @@
+
+Glosario
+========
+
+.. glossary::
+   :sorted:
+
+   *mutator*:
+      parte del programa que realiza cambios al grafo de conectividad.
+
+   recolector:
+      parte del programa que recupera celdas *muertas* (no realiza cambios en
+      el grafo de conectividad).
+
+   recolector *híbrido*:
+      recolector que emplea distintas técnicas de recolección dependiendo de
+      distintas características de las celdas (por ejemplo cuantas
+      recolecciones lleva sin ser recolectado, el tamaño de celda, etc.).
+
+   grafo de conectividad:
+      grafo conformado por la memoria del *heap*. Los vértices son las celdas
+      de memoria y las aristas las referencias (o punteros) que tiene una
+      celda apuntando a otras. Ver :ref:`gc_intro_basics`.
+
+   abstracción bicolor:
+      método para marcar todas las celdas de un grafo que sea accesibles de
+      forma transitiva a partir de una o más raíces que consiste en *pintar*
+      todas las celdas de blanco inicialmente y luego, a medida que son
+      visitadas, pintarlas de negro. Al finalizar el proceso las celdas
+      accesibles están pintadas de negro y el resto de blanco. Ver
+      :ref:`gc_intro_mark`.
+
+   abstracción tricolor:
+      método para marcar todas las celdas de un grafo que sea accesibles de
+      forma transitiva a partir de una o más raíces que consiste en *pintar*
+      todas las celdas de blanco inicialmente y luego, a medida que son
+      visitadas, pintarlas de gris y finalmente, cuando todas sus *hijas* son
+      visitadas también, de negro. Al finalizar el proceso las celdas
+      accesibles están pintadas de negro y el resto de blanco. Ver
+      :ref:`gc_intro_tricolor`.
+
+   celda:
+      porción contigua de memoria destinada a almacenar un objeto o estructura
+      de dato particular.
+
+   celda *blanca*:
+      en la abstracción bicolor y tricolor, son celdas que no fueron aún
+      visitadas por la fase de marcado.
+
+   celda *negra*:
+      en la abstracción bicolor y tricolor, son celdas que ya fueron
+      visitadas por completo (es decir, incluyendo sus celdas *hijas*) por la
+      fase de marcado.
+
+   celda *gris*:
+      en la abstracción tricolor, son celdas que ya fueron visitadas por la
+      fase de marcado pero deben ser visitadas nuevamente (porque sus *hijas*
+      no fueron visitadas por completo todavía o porque hubo algún cambio en
+      la celda).
+
+   celda *hija*:
+      celda para la cual existe una referencia desde la celda actual. Se dice
+      que *H* es *hija* de *P* si *P* contiene una referencia a *H*.
+
+   celda *jóven*:
+      celda que no lleva ninguna (o muy pocas) recolecciones sin ser
+      recolectada.
+
+   celda *vieja*:
+      celda que lleva varias recolecciones sin ser recolectada.
+
+   celda *viva*:
+      celda de memoria que puede ser accedida transitivamente a través del
+      *root set*.
+
+   celda *muerta*:
+      celda de memoria que no puede ser accedida transitivamente a través del
+      *root set*.
+
+   *basura*:
+      dependiendo del contexto, se refiere a una celda *muerta*, un conjunto
+      de celdas *muertas* o al conjunto completo de celdas *muertas*.
+
+   *root set*:
+      conjunto de celdas de memoria que sirven como punto de partida para
+      recorrer el grafo de conectividad. En general se compone de memoria
+      estática, registros y el *stack*.
+
+   *live set*:
+      conjunto de todas las celdas *vivas*.
+
+   palabra:
+      tamaño de dato característico de un procesador que permite almacenar una
+      dirección de memoria. Generalmente este tamaño coincide con el tamaño de
+      dato que el procesador puede manipular de forma más eficiente.
+
+   registro:
+      memoria muy veloz del procesador que por lo general tiene el tamaño de
+      una palabra. En general son muy escasos y es donde los procesadores
+      hacen realmente los cálculos.
+
+   *heap*:
+      área de memoria que en la cual se asigna y liberan celdas dinámicamente
+      (durante la ejecución del programa).
+
+   *stack*:
+      área de memoria organizada en forma de pila donde se almacenan
+      típicamente las variables locales, parámetros, valor de retorno
+      y dirección de retorno de las subrutinas
+
+   *dangling pointer*:
+      (o *puntero colgante* en castellano) puntero que almacena una dirección
+      de memoria inválida.
+
+   localidad de referencia:
+      medida en que los accesos sucesivos de memoria cercana espacialmente son
+      cercanos también en el tiempo. Por ejemplo, un programa que lee todos
+      los elementos de una matriz contigua de una vez o que utiliza la misma
+      variable repetidamente tiene buena localidad referencia.
+
+   *working set*:
+      conjunto de celdas con la que trabaja el programa de forma intensiva
+      durante un período considerable de tiempo.
+
+   *hit rate*:
+      frecuencia con la que el caché puede responder con éxito.
+
+   *cache*:
+      memoria pequeña (por ser típicamente muy costosa) pero muy veloz.
+
+   memoria estática:
+      memoria fija destinada a un programa. Es fija en el sentido en que no
+      varía su tamaño ni puede asignarse o liberarse durante la ejecución del
+      programa.
+
+   referencia débil:
+      referencia que no es tomada en cuenta en el grafo de conectividad (es
+      decir, si un objeto es solamente alcanzable a través de una referencia
+      débil, puede ser reciclado por el recolector).
+
+   *weak reference*:
+      ver referencia débil.
+
+   ciclo:
+      un conjunto de celdas que están referenciadas entre sí de forma tal que
+      siempre se puede llegar de una celda a sí misma a través de las
+      referencias.
+
+   *low level allocator*:
+      administrador de memoria de bajo nivel que obtiene la memoria del
+      sistema operativo y la provee al recolector (o al *mutator*
+      directamente).
+
+   *fragmentación*:
+      incapacidad de usar memoria debido a la disposición de memoria
+      actualmente en uso, que deja la memoria libre dividida en bloques
+      demasiado pequeños.
+
+   *multi-core*:
+      arquitectura que combina dos o más núcleos (*cores*) independientes que
+      trabajan a la misma frecuencia, pero dentro de un solo circuito
+      integrado o procesador.
+
+   *pinning*:
+      técnica que consiste en marcar una celda como inmóvil. Generalmente se
+      utiliza en recolectores semi-conservativos con movimiento para no mover
+      celdas que son alcanzadas desde palabras para las que no se tiene
+      información de tipos.
+
+   puntero *interior*:
+      puntero que en vez de apuntar al inicio de una celda, apuntan a una
+      dirección arbitraria dentro de ella.
+
+   *two level allocators*:
+      administrador de memoria que utiliza dos niveles para organizar las
+      celdas de memoria; obtiene del sistema operativo páginas completas
+      y éstas a su vez de dividen en bloques que son utilizados para almacenar
+      las celdas.
+
+   página:
+      unidad mínima de memoria que asigna el sistema operativo a un programa
+      (típicamente el tamaño de página es de 4096 bytes).
+
+   dirección:
+      una dirección de memoria es la especificación de su ubicación en
+      memoria. Típicamente se representan como enteros sin signo y ocupan una
+      palabra.
+
+   *address space*:
+      conjunto de posibles direcciones de memoria asignada a un programa.
+      Puede ser un conjunto no contiguo o espaciado.
+
+   *lock*:
+      también conocido como *mutex* (abreviación de *exclusión mutua* en
+      inglés), es un objeto de sincronización que permite serializar la
+      ejecución de múltiples hilos.
+
+   *best-fit*:
+      búsqueda para encontrar la región de memoria contigua libre que mejor se
+      ajuste al tamaño de un objeto (es decir, la región más pequeña lo
+      suficientemente grande como para almacenarlo).
+
+   *first-fit*:
+      búsqueda para encontrar la primera región de memoria contigua libre
+      donde quepa un objeto (es decir, la primera región lo suficientemente
+      grande como para almacenar el objeto a asignar).
+
+   *stack overflow*:
+      ver *desbordamiento de pila*.
+
+   desbordamiento de pila:
+      agotamiento del *stack*.
+
+   *bitset*:
+      ver conjunto de bits.
+
+   conjunto de bits:
+      estructura de datos que sirve para almacenar un conjunto de indicadores
+      de forma eficiente. Generalmente se implementa utilizando una porción de
+      memoria donde cada bit es un indicador; si el bit está en 0 el indicador
+      no está presente y si está en 1, el indicador está activado. La
+      manipulación de los bits (individuales y en conjunto) en general se
+      realiza de forma eficiente utilizando máscaras.
+
+   *system programming*:
+      se refiere a programación de bajo nivel. En general involucra
+      manipulación de punteros, acceso directo al lenguaje de máquina y por
+      consiguiente al *hardware*.
+
+   *parsing*:
+      análisis sintáctico de un lenguaje estructurado.
+
+   *context-free grammar*:
+      gramática que no depende del contexto (es decir, de información
+      semántica).
+
+   *templates*:
+      técnica para construir algoritmos genéricos incluyendo parámetros como
+      tipos o valores.
+
+   *string*:
+      secuencia lineal de caracteres utilizada normalmente en los lenguajes de
+      programación para representar texto (aunque pueden ser utilizados para
+      representar una secuencia lineal de bytes de cualquier tipo también).
+
+   *mixin*:
+      en D_ se refiere a un fragmento de código (M) que puede incluirse dentro
+      de otro (O) como si M hubiera sido escrito directamente dentro de O. En
+      general se utiliza para suplantar la herencia múltiple pero tiene muchos
+      otros usos.
+
+   función *pura*:
+      función que no tiene efectos secundarios. Una función pura ejecutada con
+      los mismo parámetros siempre devuelve el mismo resultado.
+
+   *runtime*:
+      biblioteca base de un lenguaje que provee los servicios básicos (como
+      creación de objetos, manejo de hilos u otras construcciones que ofrezca
+      el lenguaje).
+
+   *tipado* estático:
+      verificación de tipos en tiempo de compilación.
+
+   *tipado* dinámico:
+      verificación de tipos en tiempo de ejecución.
+
+   verificación de tipos:
+      forma en la que un sistema de tipos asigna tipos y verifica sus
+      interacciones.
+
+   sistema de tipos:
+      forma en que un lenguaje de programación clasifica valores y expresiones
+      en tipos, como los manipula y como interactúan éstos entre sí.
+
+   conversión *covariante*:
+      conversión de tipos que preserva el orden de los tipos de más
+      específicos a más genéricos.
+
+   *type-safe*:
+      operación que no compromete ni subvierte la verificación de tipos.
+
+   *excepción*:
+      construcción de un lenguaje de programación para manejar la presencia de
+      situaciones anormales (en general errores) cambiando el flujo de
+      ejecución del programa.
+
+   *exception-safe*:
+      propiedad de un programa que ante un error en tiempo de ejecución
+      manifestado como una *excepción* no provoca efectos indeseados (como
+      pérdida de memoria, corrupción de datos o salida inválida).
+
+   *thread-safe*:
+      propiedad de una función o fragmento de código que permite que corra
+      concurrentemente en dos o más hilos de ejecución paralelos sin provocar
+      efectos indeseados (como pérdida de memoria, corrupción de datos
+      o salida inválida).
+
+   *CTFE*:
+      abreviatura en inglés de *Compile-Time Function Execution*, es la
+      capacidad de un lenguaje de programación de ejecutar una función en
+      tiempo de compilación en vez de tiempo de ejecución.
+
+   *ABI*:
+      abreviatura en inglés de *Application Binary Interface*, es la interfaz
+      de bajo nivel entre un programa y el sistema operativo u otro programa.
+
+   arreglo:
+      disposición de celdas de igual tamaño de forma consecutiva en la memoria
+      de manera que puedan ser fácilmente indizadas.
+
+   *overhead*:
+      cualquier combinación de exceso directo o indirecto de tiempo de
+      computación, memoria, ancho de banda u otro recurso que sea requerido
+      para cumplir un objetivo particular.
+
+   *pattern matching*:
+      acto de verificar la presencia de un constituyente sintáctico de un
+      patrón dado.
+
+   *activation record*:
+      ver *stack frame*.
+
+   *stack frame*:
+      estructura de datos dependiente de la arquitectura que contiene
+      información del estado de una función, incluyendo, por ejemplo, sus
+      variables locales, parámetros y dirección de retorno.
+
+   *delegado*:
+      es una estructura simple que modela una función acompañada de un
+      contexto. En general se utiliza para representar un puntero a una
+      función miembro de un objeto en particular o a una función anidada
+      (donde el contexto es el *stack frame* de la función que la contiene).
+
+   ciudadano de primera clase:
+      tipo soportado por completo por el lenguaje (por ejemplo disponen de
+      expresiones literales anónimas, pueden ser almacenados en variables
+      y estructuras de datos, tienen una identidad intrínseca, etc.).
+
+   semántica de valor:
+      propiedad de los tipos son tratado como si fuera un valor concreto. En
+      general se pasa por valor y se hacen copias a menos que se utilice
+      explícitamente un puntero.
+
+   semántica de referencia:
+      propiedad de los tipos que son tratados como si fueran un puntero. Nunca
+      se hacen copias del objeto, siempre se pasa por referencia
+      implícitamente.
+
+   *slicing*:
+      problema que surge cuando los objetos polimórficos tienen semántica de
+      valor, consiste en pasar una clase derivada a una función que acepta una
+      clase base por valor como parámetro. Al realizarse la copia, se utiliza
+      solo la parte de la clase base y se pierden (o *rebanan*) los atributos
+      de la clase derivada, y la información de tipos en tiempo de ejecución
+      (*RTTI*).
+
+   *RTTI*:
+      abreviatura del inglés *Run-Time Type Identification*, es la información
+      de tipos disponible en tiempo de ejecución.
+
+   *DbC*:
+      ver diseño por contrato (del inglés *Design by Contract*).
+
+   *diseño por contrato*:
+      técnica de diseño de software que consiste en especificar formalmente,
+      de forma precisa y verificable, la interfaz entre componentes de
+      software.
+
+   *RAII*:
+      técnica que consiste en reservar recursos por medio de la construcción
+      de un objeto y liberarlos cuando éste se libera (del inglés *Resourse
+      Adquisition Is Initialization*).
+
+   *front-end*:
+      parte del compilador encargada de hacer el análisis léxico, sintáctico
+      y semántico del código fuente, generando una representación intermedia
+      que luego el *back-end* convierte a código de máquina.
+
+   *back-end*:
+      parte del compilador encargada de convertir la representación intermedia
+      generada por el *front-end* a código de máquina.
+
+   finalización:
+      referente a la acción de llamar a una función miembro de un objeto,
+      generalmente llamada destructor, cuando éste deja de ser utilizado.
+
+   determinístico:
+      algoritmo o proceso que se comporta de forma predecible (dada una cierta
+      entrada siempre produce el mismo resultado y los pasos realizados son
+      exactamente los mismo, pasando por la misma secuencia de estados).
+
+   fase de marcado:
+      primera fase del algoritmo *marcado y barrido* (entre otros). Ver
+      :ref:`gc_intro_mark` y :ref:`gc_mark_sweep`.
+
+   fase de barrido:
+      segunda fase del algoritmo *marcado y barrido*. Ver
+      :ref:`gc_mark_sweep`.
+
+   conteo de referencias:
+      uno de los tres principales algoritmos clásicos de recolección de
+      basura. Ver :ref:`gc_rc`.
+
+   marcado y barrido:
+      uno de los tres principales algoritmos clásicos de recolección de
+      basura. Ver :ref:`gc_mark_sweep`.
+
+   copia de semi-espacio:
+      uno de los tres principales algoritmos clásicos de recolección de
+      basura. Ver :ref:`gc_copy`.
+
+   *semi-space*:
+      nombre alternativo para el algoritmo *copia de semi-espacios*. Ver
+      :ref:`gc_copy`.
+
+   *two-space*:
+      nombre alternativo para el algoritmo *copia de semi-espacios*. Ver
+      :ref:`gc_copy`.
+
+   *copying collector*:
+      nombre alternativo para el algoritmo *copia de semi-espacios*, aunque
+      puede referirse también a una familia más general de algoritmos con
+      movimiento de celdas. Ver :ref:`gc_copy` y :ref:`gc_moving`.
+
+   *fromspace*:
+      uno de los dos semi-espacios del algoritmo *copia de semi-espacios*. Ver
+      :ref:`gc_copy`.
+
+   *tospace*:
+      uno de los dos semi-espacios del algoritmo *copia de semi-espacios*. Ver
+      :ref:`gc_copy`.
+
+   *forwarding address*:
+     dirección de memoria de re-dirección utilizada para localizar la nueva
+     ubicación de una celda en algoritmos de recolección con movimiento. Ver
+     :ref:`gc_copy`.
+
+   recolección directa:
+      recolección en la cual el compilador o lenguaje instrumenta al *mutator*
+      de forma tal que la información sobre el grafo de conectividad se
+      mantenga activamente cada vez que hay un cambio en él. Ver
+      :ref:`gc_direct`.
+
+   recolección indirecta:
+      recolección que, generalmente, no interfiere con el *mutator* en cada
+      actualización del grafo de conectividad. Ver :ref:`gc_direct`.
+
+   recolección incremental:
+      recolección que se realiza de forma intercalada con el *mutator*. Ver
+      :ref:`gc_inc`.
+
+   recolección concurrente:
+      recolección que puede correr en paralelo con el *mutator*. Ver
+      :ref:`gc_concurrent`.
+
+   recolección paralela:
+      recolección que puede correr en paralelo en varios hilos. Ver
+      :ref:`gc_concurrent`.
+
+   recolección *stop-the-world*:
+      recolección que detiene todos los hilos del *mutator*. Ver
+      :ref:`gc_concurrent`.
+
+   *stop-the-world*:
+      ver *recolección stop-the-world*.
+
+   lista de libres:
+      forma de organizar el *heap* en la cual se asigna una nueva celda
+      obteniéndola de una lista de celdas libres. Ver :ref:`gc_free_list`.
+
+   *pointer bump allocation*:
+      forma de organizar el *heap* en la cual se asigna una nueva celda
+      incrementando un puntero. Ver :ref:`gc_free_list`.
+
+   recolección con movimiento de celdas:
+      recolección en la cual una celda de memoria puede ser movida a otra
+      ubicación en el *heap*. Ver :ref:`gc_moving`.      
+
+   recolección conservativa:
+      recolección que no tiene información de tipos y trata cada palabra del
+      *root set* o *heap* como un posible puntero. Ver :ref:`gc_conserv`.
+
+   recolección precisa:
+      recolección que tiene información de tipos completa y puede determinar
+      exactamente que palabras son punteros y cuales no. Ver
+      :ref:`gc_conserv`.
+
+   recolección semi-precisa:
+      recolección que tiene información de tipos parcial y puede determinar
+      para algunas palabras si son punteros o no, y para otras las trata como
+      punteros potenciales. Ver :ref:`gc_conserv`.
+
+   *falso positivo*:
+      palabra que es tratada como un potencial puntero cuyo valor almacenado
+      coincide con una dirección válida dentro del *heap* pero que en realidad
+      no es un puntero.
+
+   recolección por particiones:
+      recolección en la que se divide el *heap* en particiones con el objetivo
+      de recolectar la partición con mayor concentración de *basura*. Ver
+      :ref:`gc_part`.
+
+   recolección generacional:
+      caso particular de *recolección por particiones* en el cual las
+      particiones se realizan utilizando la cantidad de recolecciones que
+      *sobrevive* una celda. Ver :ref:`gc_part`.
+
+   *benchmark*:
+      banco de pruebas utilizado para medir y comparar el rendimiento de un
+      programa, algoritmo o proceso en general.
+
+
+.. include:: links.rst
+
+.. vim: set ts=3 sts=3 sw=3 et tw=78 :
diff --git a/source/index.rst b/source/index.rst
index 9d5ac7f..f8f8273 100644
--- a/source/index.rst
+++ b/source/index.rst
@@ -34,6 +34,7 @@
    viabilidad
    solucion
    conclusion
+   glosario
 
 
 .. Pone links "offline" (para generar PDF para imprimir).
-- 
2.43.0