source/glosario.rst

   1
   2 Glosario
   3 ========
   4
   5 .. glossary::
   6    :sorted:
   7
   8    *mutator*
   9       parte del programa que realiza cambios al grafo de conectividad.
  10
  11    recolector
  12       parte del programa que recupera celdas *muertas* (no realiza cambios en
  13       el grafo de conectividad).
  14
  15    recolector *híbrido*
  16       recolector que emplea distintas técnicas de recolección dependiendo de
  17       distintas características de las celdas (por ejemplo cuantas
  18       recolecciones lleva sin ser recolectado, el tamaño de celda, etc.).
  19
  20    grafo de conectividad
  21       grafo conformado por la memoria del *heap*. Los vértices son las celdas
  22       de memoria y las aristas las referencias (o punteros) que tiene una
  23       celda apuntando a otras. Ver :ref:`gc_intro_basics`.
  24
  25    abstracción bicolor
  26       método para marcar todas las celdas de un grafo que sea accesibles de
  27       forma transitiva a partir de una o más raíces que consiste en *pintar*
  28       todas las celdas de blanco inicialmente y luego, a medida que son
  29       visitadas, pintarlas de negro. Al finalizar el proceso las celdas
  30       accesibles están pintadas de negro y el resto de blanco. Ver
  31       :ref:`gc_intro_mark`.
  32
  33    abstracción tricolor
  34       método para marcar todas las celdas de un grafo que sea accesibles de
  35       forma transitiva a partir de una o más raíces que consiste en *pintar*
  36       todas las celdas de blanco inicialmente y luego, a medida que son
  37       visitadas, pintarlas de gris y finalmente, cuando todas sus *hijas* son
  38       visitadas también, de negro. Al finalizar el proceso las celdas
  39       accesibles están pintadas de negro y el resto de blanco. Ver
  40       :ref:`gc_intro_tricolor`.
  41
  42    celda
  43       porción contigua de memoria destinada a almacenar un objeto o estructura
  44       de dato particular.
  45
  46    celda *blanca*
  47       en la abstracción bicolor y tricolor, son celdas que no fueron aún
  48       visitadas por la fase de marcado.
  49
  50    celda *negra*
  51       en la abstracción bicolor y tricolor, son celdas que ya fueron
  52       visitadas por completo (es decir, incluyendo sus celdas *hijas*) por la
  53       fase de marcado.
  54
  55    celda *gris*
  56       en la abstracción tricolor, son celdas que ya fueron visitadas por la
  57       fase de marcado pero deben ser visitadas nuevamente (porque sus *hijas*
  58       no fueron visitadas por completo todavía o porque hubo algún cambio en
  59       la celda).
  60
  61    celda *hija*
  62       celda para la cual existe una referencia desde la celda actual. Se dice
  63       que *H* es *hija* de *P* si *P* contiene una referencia a *H*.
  64
  65    celda *jóven*
  66       celda que no lleva ninguna (o muy pocas) recolecciones sin ser
  67       recolectada.
  68
  69    celda *vieja*
  70       celda que lleva varias recolecciones sin ser recolectada.
  71
  72    celda *viva*
  73       celda de memoria que puede ser accedida transitivamente a través del
  74       *root set*.
  75
  76    celda *muerta*
  77       celda de memoria que no puede ser accedida transitivamente a través del
  78       *root set*.
  79
  80    *basura*
  81       dependiendo del contexto, se refiere a una celda *muerta*, un conjunto
  82       de celdas *muertas* o al conjunto completo de celdas *muertas*.
  83
  84    *root set*
  85       conjunto de celdas de memoria que sirven como punto de partida para
  86       recorrer el grafo de conectividad. En general se compone de memoria
  87       estática, registros y el *stack*.
  88
  89    *live set*
  90       conjunto de todas las celdas *vivas*.
  91
  92    palabra
  93       tamaño de dato característico de un procesador que permite almacenar una
  94       dirección de memoria. Generalmente este tamaño coincide con el tamaño de
  95       dato que el procesador puede manipular de forma más eficiente.
  96
  97    registro
  98       memoria muy veloz del procesador que por lo general tiene el tamaño de
  99       una palabra. En general son muy escasos y es donde los procesadores
 100       hacen realmente los cálculos.
 101
 102    *heap*
 103       área de memoria que en la cual se asigna y liberan celdas dinámicamente
 104       (durante la ejecución del programa).
 105
 106    *stack*
 107       área de memoria organizada en forma de pila donde se almacenan
 108       típicamente las variables locales, parámetros, valor de retorno
 109       y dirección de retorno de las subrutinas
 110
 111    *dangling pointer*
 112       (o *puntero colgante* en castellano) puntero que almacena una dirección
 113       de memoria inválida.
 114
 115    localidad de referencia
 116       medida en que los accesos sucesivos de memoria cercana espacialmente son
 117       cercanos también en el tiempo. Por ejemplo, un programa que lee todos
 118       los elementos de una matriz contigua de una vez o que utiliza la misma
 119       variable repetidamente tiene buena localidad referencia.
 120
 121    *working set*
 122       conjunto de celdas con la que trabaja el programa de forma intensiva
 123       durante un período considerable de tiempo.
 124
 125    *hit rate*
 126       frecuencia con la que el caché puede responder con éxito.
 127
 128    *cache*
 129       memoria pequeña (por ser típicamente muy costosa) pero muy veloz.
 130
 131    memoria estática
 132       memoria fija destinada a un programa. Es fija en el sentido en que no
 133       varía su tamaño ni puede asignarse o liberarse durante la ejecución del
 134       programa.
 135
 136    referencia débil
 137       referencia que no es tomada en cuenta en el grafo de conectividad (es
 138       decir, si un objeto es solamente alcanzable a través de una referencia
 139       débil, puede ser reciclado por el recolector).
 140
 141    *weak reference*
 142       ver referencia débil.
 143
 144    ciclo
 145       un conjunto de celdas que están referenciadas entre sí de forma tal que
 146       siempre se puede llegar de una celda a sí misma a través de las
 147       referencias.
 148
 149    *low level allocator*
 150       administrador de memoria de bajo nivel que obtiene la memoria del
 151       sistema operativo y la provee al recolector (o al *mutator*
 152       directamente).
 153
 154    *fragmentación*
 155       incapacidad de usar memoria debido a la disposición de memoria
 156       actualmente en uso, que deja la memoria libre dividida en bloques
 157       demasiado pequeños.
 158
 159    *multi-core*
 160       arquitectura que combina dos o más núcleos (*cores*) independientes que
 161       trabajan a la misma frecuencia, pero dentro de un solo circuito
 162       integrado o procesador.
 163
 164    *pinning*
 165       técnica que consiste en marcar una celda como inmóvil. Generalmente se
 166       utiliza en recolectores semi-conservativos con movimiento para no mover
 167       celdas que son alcanzadas desde palabras para las que no se tiene
 168       información de tipos.
 169
 170    puntero *interior*
 171       puntero que en vez de apuntar al inicio de una celda, apuntan a una
 172       dirección arbitraria dentro de ella.
 173
 174    *two level allocators*
 175       administrador de memoria que utiliza dos niveles para organizar las
 176       celdas de memoria; obtiene del sistema operativo páginas completas
 177       y éstas a su vez de dividen en bloques que son utilizados para almacenar
 178       las celdas.
 179
 180    página
 181       unidad mínima de memoria que asigna el sistema operativo a un programa
 182       (típicamente el tamaño de página es de 4096 bytes).
 183
 184    dirección
 185       una dirección de memoria es la especificación de su ubicación en
 186       memoria. Típicamente se representan como enteros sin signo y ocupan una
 187       palabra.
 188
 189    *address space*
 190       conjunto de posibles direcciones de memoria asignada a un programa.
 191       Puede ser un conjunto no contiguo o espaciado.
 192
 193    *lock*
 194       también conocido como *mutex* (abreviación de *exclusión mutua* en
 195       inglés), es un objeto de sincronización que permite serializar la
 196       ejecución de múltiples hilos.
 197
 198    *best-fit*
 199       búsqueda para encontrar la región de memoria contigua libre que mejor se
 200       ajuste al tamaño de un objeto (es decir, la región más pequeña lo
 201       suficientemente grande como para almacenarlo).
 202
 203    *first-fit*
 204       búsqueda para encontrar la primera región de memoria contigua libre
 205       donde quepa un objeto (es decir, la primera región lo suficientemente
 206       grande como para almacenar el objeto a asignar).
 207
 208    *stack overflow*
 209       ver *desbordamiento de pila*.
 210
 211    desbordamiento de pila
 212       agotamiento del *stack*.
 213
 214    *bitset*
 215       ver conjunto de bits.
 216
 217    conjunto de bits
 218       estructura de datos que sirve para almacenar un conjunto de indicadores
 219       de forma eficiente. Generalmente se implementa utilizando una porción de
 220       memoria donde cada bit es un indicador; si el bit está en 0 el indicador
 221       no está presente y si está en 1, el indicador está activado. La
 222       manipulación de los bits (individuales y en conjunto) en general se
 223       realiza de forma eficiente utilizando máscaras.
 224
 225    *system programming*
 226       se refiere a programación de bajo nivel. En general involucra
 227       manipulación de punteros, acceso directo al lenguaje de máquina y por
 228       consiguiente al *hardware*.
 229
 230    *parsing*
 231       análisis sintáctico de un lenguaje estructurado.
 232
 233    *context-free grammar*
 234       gramática que no depende del contexto (es decir, de información
 235       semántica).
 236
 237    *templates*
 238       técnica para construir algoritmos genéricos incluyendo parámetros como
 239       tipos o valores.
 240
 241    *string*
 242       secuencia lineal de caracteres utilizada normalmente en los lenguajes de
 243       programación para representar texto (aunque pueden ser utilizados para
 244       representar una secuencia lineal de bytes de cualquier tipo también).
 245
 246    *mixin*
 247       en D_ se refiere a un fragmento de código (M) que puede incluirse dentro
 248       de otro (O) como si M hubiera sido escrito directamente dentro de O. En
 249       general se utiliza para suplantar la herencia múltiple pero tiene muchos
 250       otros usos.
 251
 252    función *pura*
 253       función que no tiene efectos secundarios. Una función pura ejecutada con
 254       los mismo parámetros siempre devuelve el mismo resultado.
 255
 256    *runtime*
 257       biblioteca base de un lenguaje que provee los servicios básicos (como
 258       creación de objetos, manejo de hilos u otras construcciones que ofrezca
 259       el lenguaje).
 260
 261    *tipado* estático
 262       verificación de tipos en tiempo de compilación.
 263
 264    *tipado* dinámico
 265       verificación de tipos en tiempo de ejecución.
 266
 267    verificación de tipos
 268       forma en la que un sistema de tipos asigna tipos y verifica sus
 269       interacciones.
 270
 271    sistema de tipos
 272       forma en que un lenguaje de programación clasifica valores y expresiones
 273       en tipos, como los manipula y como interactúan éstos entre sí.
 274
 275    conversión *covariante*
 276       conversión de tipos que preserva el orden de los tipos de más
 277       específicos a más genéricos.
 278
 279    *type-safe*
 280       operación que no compromete ni subvierte la verificación de tipos.
 281
 282    *excepción*
 283       construcción de un lenguaje de programación para manejar la presencia de
 284       situaciones anormales (en general errores) cambiando el flujo de
 285       ejecución del programa.
 286
 287    *exception-safe*
 288       propiedad de un programa que ante un error en tiempo de ejecución
 289       manifestado como una *excepción* no provoca efectos indeseados (como
 290       pérdida de memoria, corrupción de datos o salida inválida).
 291
 292    *thread-safe*
 293       propiedad de una función o fragmento de código que permite que corra
 294       concurrentemente en dos o más hilos de ejecución paralelos sin provocar
 295       efectos indeseados (como pérdida de memoria, corrupción de datos
 296       o salida inválida).
 297
 298    *CTFE*
 299       abreviatura en inglés de *Compile-Time Function Execution*, es la
 300       capacidad de un lenguaje de programación de ejecutar una función en
 301       tiempo de compilación en vez de tiempo de ejecución.
 302
 303    *ABI*
 304       abreviatura en inglés de *Application Binary Interface*, es la interfaz
 305       de bajo nivel entre un programa y el sistema operativo u otro programa.
 306
 307    arreglo
 308       disposición de celdas de igual tamaño de forma consecutiva en la memoria
 309       de manera que puedan ser fácilmente indizadas.
 310
 311    *overhead*
 312       cualquier combinación de exceso directo o indirecto de tiempo de
 313       computación, memoria, ancho de banda u otro recurso que sea requerido
 314       para cumplir un objetivo particular.
 315
 316    *pattern matching*
 317       acto de verificar la presencia de un constituyente sintáctico de un
 318       patrón dado.
 319
 320    *activation record*
 321       ver *stack frame*.
 322
 323    *stack frame*
 324       estructura de datos dependiente de la arquitectura que contiene
 325       información del estado de una función, incluyendo, por ejemplo, sus
 326       variables locales, parámetros y dirección de retorno.
 327
 328    *delegado*
 329       es una estructura simple que modela una función acompañada de un
 330       contexto. En general se utiliza para representar un puntero a una
 331       función miembro de un objeto en particular o a una función anidada
 332       (donde el contexto es el *stack frame* de la función que la contiene).
 333
 334    ciudadano de primera clase
 335       tipo soportado por completo por el lenguaje (por ejemplo disponen de
 336       expresiones literales anónimas, pueden ser almacenados en variables
 337       y estructuras de datos, tienen una identidad intrínseca, etc.).
 338
 339    semántica de valor
 340       propiedad de los tipos son tratado como si fuera un valor concreto. En
 341       general se pasa por valor y se hacen copias a menos que se utilice
 342       explícitamente un puntero.
 343
 344    semántica de referencia
 345       propiedad de los tipos que son tratados como si fueran un puntero. Nunca
 346       se hacen copias del objeto, siempre se pasa por referencia
 347       implícitamente.
 348
 349    *slicing*
 350       problema que surge cuando los objetos polimórficos tienen semántica de
 351       valor, consiste en pasar una clase derivada a una función que acepta una
 352       clase base por valor como parámetro. Al realizarse la copia, se utiliza
 353       solo la parte de la clase base y se pierden (o *rebanan*) los atributos
 354       de la clase derivada, y la información de tipos en tiempo de ejecución
 355       (*RTTI*).
 356
 357    *RTTI*
 358       abreviatura del inglés *Run-Time Type Identification*, es la información
 359       de tipos disponible en tiempo de ejecución.
 360
 361    *DbC*
 362       ver diseño por contrato (del inglés *Design by Contract*).
 363
 364    *diseño por contrato*
 365       técnica de diseño de software que consiste en especificar formalmente,
 366       de forma precisa y verificable, la interfaz entre componentes de
 367       software.
 368
 369    *RAII*
 370       técnica que consiste en reservar recursos por medio de la construcción
 371       de un objeto y liberarlos cuando éste se libera (del inglés *Resourse
 372       Adquisition Is Initialization*).
 373
 374    *front-end*
 375       parte del compilador encargada de hacer el análisis léxico, sintáctico
 376       y semántico del código fuente, generando una representación intermedia
 377       que luego el *back-end* convierte a código de máquina.
 378
 379    *back-end*
 380       parte del compilador encargada de convertir la representación intermedia
 381       generada por el *front-end* a código de máquina.
 382
 383    finalización
 384       referente a la acción de llamar a una función miembro de un objeto,
 385       generalmente llamada destructor, cuando éste deja de ser utilizado.
 386
 387    determinístico
 388       algoritmo o proceso que se comporta de forma predecible (dada una cierta
 389       entrada siempre produce el mismo resultado y los pasos realizados son
 390       exactamente los mismo, pasando por la misma secuencia de estados).
 391
 392    fase de marcado
 393       primera fase del algoritmo *marcado y barrido* (entre otros). Ver
 394       :ref:`gc_intro_mark` y :ref:`gc_mark_sweep`.
 395
 396    fase de barrido
 397       segunda fase del algoritmo *marcado y barrido*. Ver
 398       :ref:`gc_mark_sweep`.
 399
 400    conteo de referencias
 401       uno de los tres principales algoritmos clásicos de recolección de
 402       basura. Ver :ref:`gc_rc`.
 403
 404    marcado y barrido
 405       uno de los tres principales algoritmos clásicos de recolección de
 406       basura. Ver :ref:`gc_mark_sweep`.
 407
 408    copia de semi-espacio
 409       uno de los tres principales algoritmos clásicos de recolección de
 410       basura. Ver :ref:`gc_copy`.
 411
 412    *semi-space*
 413       nombre alternativo para el algoritmo *copia de semi-espacios*. Ver
 414       :ref:`gc_copy`.
 415
 416    *two-space*
 417       nombre alternativo para el algoritmo *copia de semi-espacios*. Ver
 418       :ref:`gc_copy`.
 419
 420    *copying collector*
 421       nombre alternativo para el algoritmo *copia de semi-espacios*, aunque
 422       puede referirse también a una familia más general de algoritmos con
 423       movimiento de celdas. Ver :ref:`gc_copy` y :ref:`gc_moving`.
 424
 425    *fromspace*
 426       uno de los dos semi-espacios del algoritmo *copia de semi-espacios*. Ver
 427       :ref:`gc_copy`.
 428
 429    *tospace*
 430       uno de los dos semi-espacios del algoritmo *copia de semi-espacios*. Ver
 431       :ref:`gc_copy`.
 432
 433    *forwarding address*
 434      dirección de memoria de re-dirección utilizada para localizar la nueva
 435      ubicación de una celda en algoritmos de recolección con movimiento. Ver
 436      :ref:`gc_copy`.
 437
 438    recolección directa
 439       recolección en la cual el compilador o lenguaje instrumenta al *mutator*
 440       de forma tal que la información sobre el grafo de conectividad se
 441       mantenga activamente cada vez que hay un cambio en él. Ver
 442       :ref:`gc_direct`.
 443
 444    recolección indirecta
 445       recolección que, generalmente, no interfiere con el *mutator* en cada
 446       actualización del grafo de conectividad. Ver :ref:`gc_direct`.
 447
 448    recolección incremental
 449       recolección que se realiza de forma intercalada con el *mutator*. Ver
 450       :ref:`gc_inc`.
 451
 452    recolección concurrente
 453       recolección que puede correr en paralelo con el *mutator*. Ver
 454       :ref:`gc_concurrent`.
 455
 456    recolección paralela
 457       recolección que puede correr en paralelo en varios hilos. Ver
 458       :ref:`gc_concurrent`.
 459
 460    recolección *stop-the-world*
 461       recolección que detiene todos los hilos del *mutator*. Ver
 462       :ref:`gc_concurrent`.
 463
 464    *stop-the-world*
 465       ver *recolección stop-the-world*.
 466
 467    lista de libres
 468       forma de organizar el *heap* en la cual se asigna una nueva celda
 469       obteniéndola de una lista de celdas libres. Ver :ref:`gc_free_list`.
 470
 471    *pointer bump allocation*
 472       forma de organizar el *heap* en la cual se asigna una nueva celda
 473       incrementando un puntero. Ver :ref:`gc_free_list`.
 474
 475    recolección con movimiento de celdas
 476       recolección en la cual una celda de memoria puede ser movida a otra
 477       ubicación en el *heap*. Ver :ref:`gc_moving`.
 478
 479    recolección conservativa
 480       recolección que no tiene información de tipos y trata cada palabra del
 481       *root set* o *heap* como un posible puntero. Ver :ref:`gc_conserv`.
 482
 483    recolección precisa
 484       recolección que tiene información de tipos completa y puede determinar
 485       exactamente que palabras son punteros y cuales no. Ver
 486       :ref:`gc_conserv`.
 487
 488    recolección semi-precisa
 489       recolección que tiene información de tipos parcial y puede determinar
 490       para algunas palabras si son punteros o no, y para otras las trata como
 491       punteros potenciales. Ver :ref:`gc_conserv`.
 492
 493    *falso positivo*
 494       palabra que es tratada como un potencial puntero cuyo valor almacenado
 495       coincide con una dirección válida dentro del *heap* pero que en realidad
 496       no es un puntero.
 497
 498    recolección por particiones
 499       recolección en la que se divide el *heap* en particiones con el objetivo
 500       de recolectar la partición con mayor concentración de *basura*. Ver
 501       :ref:`gc_part`.
 502
 503    recolección generacional
 504       caso particular de *recolección por particiones* en el cual las
 505       particiones se realizan utilizando la cantidad de recolecciones que
 506       *sobrevive* una celda. Ver :ref:`gc_part`.
 507
 508    *benchmark*
 509       banco de pruebas utilizado para medir y comparar el rendimiento de un
 510       programa, algoritmo o proceso en general.
 511
 512    BNF
 513       Notación de Backus-Naur, una meta-sintaxis usada para expresar
 514       gramáticas libres de contexto.
 515
 516    CSV
 517       Formato simple para almacenar datos en forma de tabla, separados por
 518       comas (de ahí el nombre, en inglés *Comma separated values**) en un
 519       archivo de texto. Cada línea del archivo es interpretada como una fila
 520       de datos relacionados, y cada valor de separado por comas como una
 521       columna.
 522
 523    POSIX
 524       Familia de estándares de llamadas al sistema operativo definidos por la
 525       IEEE y especificados formalmente en IEEE 1003. El nombre proviene del
 526       acrónimo de *Portable Operating System Interface*, agregando la X final
 527       como representación de *UNIX*, como seña de identidad de la API.
 528
 529
 530 .. include:: links.rst
 531
 532 .. vim: set ts=3 sts=3 sw=3 et tw=78 spelllang=es :