--- /dev/null
+
+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 :
projects / z.facultad / 75.00 / informe.git / commitdiff