]> git.llucax.com Git - z.facultad/75.00/informe.git/blob - source/glosario.rst
5f2383fb0b25fba5eb571689db74235e885b6a97
[z.facultad/75.00/informe.git] / 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 :