y meta-programación:
``if`` estático (``static if``)
- puede verse como similar a la directiva del preprocesador de C/C++ ``#if``,
- pero a diferencia de esto, en D_ el ``static if`` tiene acceso a todos los
- símbolos del compilador (constantes, tipos, variables, etc).
+ Esta construcción es similar a la directiva del preprocesador de C/C++
+ ``#if``, pero a diferencia de éste, el ``static if`` de D_ tiene acceso
+ a todos los símbolos del compilador (constantes, tipos, variables, etc).
Ejemplo::
Más información en http://www.digitalmars.com/d/1.0/version.html#staticif
Inferencia de tipos básica implícita y explícita (mediante ``typeof``)
- si no se especifica un tipo al declarar una variable, se infiere del tipo
- de su valor de inicialización.
+ Si no se especifica un tipo al declarar una variable, se infiere a partir
+ del tipo de su valor de inicialización.
Ejemplo::
Más información en http://www.digitalmars.com/d/1.0/declaration.html#typeof
Iteración sobre colecciones (``foreach``)
- cualquier tipo de colección (arreglos estáticos y dinámicos, arreglos
+ Cualquier tipo de colección (arreglos estáticos y dinámicos, arreglos
asociativos, clases, estructuras o delegados) puede ser iterada mediante la
sentencia ``foreach``.
total += i;
*Templates*
- clases y funciones pueden ser generalizadas. Esto permite desarrollar
+ Tanto clases como funciones pueden ser generalizadas. Esto permite desarrollar
algoritmos genéricos sin importar el tipo de los datos de entrada, siempre
y cuando todos los tipos tengan una *interfaz* común. Esto también es
conocido como *polimorfismo en tiempo de compilación*, y es la forma más
La utilidad más prominente de los bloques generalizados se da al
acompañarse de *mixins*.
-Instanciación implícita de funciones generalizadas
- el lenguaje es capaz de deducir los parámetros siempre que no hayan
- ambigüedades.
+ Además las *templates* de D_ tienen las siguientes características
+ destacables:
- Ejemplo::
+ Instanciación implícita de funciones generalizadas
+ El lenguaje es capaz de deducir los parámetros siempre que no hayan
+ ambigüedades.
- auto i = sumar(5, 6); // i == 11
- auto f = sumar(5.0f, 6.0f); // f == 11.0f
+ Ejemplo::
-Especialización explícita y parcial de *templates*
- la especialización de *templates* consiste, al igual que en C++, en proveer
- una implementación especializada para un tipo de dato (o valor) de los
- parámetros. Especialización parcial se refiere a la capacidad de
- especializar un parámetro a través de un subtipo. Por ejemplo, se puede
- especializar un *template* para cualquier tipo de puntero, o para cualquier
- tipo de arreglo dinámico, sin necesidad de especificar el tipo al que
- apunta dicho puntero o el tipo almacenado por el arreglo.
+ auto i = sumar(5, 6); // i == 11
+ auto f = sumar(5.0f, 6.0f); // f == 11.0f
- Ejemplo de especialización::
+ Especialización explícita y parcial de *templates*
+ La especialización de *templates* consiste, al igual que en C++, en
+ proveer una implementación especializada para un tipo de dato (o valor)
+ de los parámetros. Especialización parcial se refiere a la capacidad
+ de especializar un parámetro a través de un subtipo. Por ejemplo, se
+ puede especializar un *template* para cualquier tipo de puntero, o para
+ cualquier tipo de arreglo dinámico, sin necesidad de especificar el tipo
+ al que apunta dicho puntero o el tipo almacenado por el arreglo.
- T sumar(T: int)(T x, T y) { return x + y + 1; }
- auto i = sumar(5, 6); // i == 12
- auto f = sumar(5.0f, 6.0f) // f == 11.0f
+ Ejemplo de especialización::
- Ejemplo de especialización parcial::
+ T sumar(T: int)(T x, T y) { return x + y + 1; }
+ auto i = sumar(5, 6); // i == 12
+ auto f = sumar(5.0f, 6.0f) // f == 11.0f
- T sumar(T: T*)(T x, T y) { return *x + *y; }
- int x = 5, y = 6;
- auto i = sumar(&x, &y); // i == 11
- float v = 5.0f, w = 6.0f;
- auto f = sumar(&v, &w); // f == 11.0f
+ Ejemplo de especialización parcial::
-Tipos, valores (incluyendo *strings*) y *templates* como parámetros
- esto es otro bloque de construcción importantísimo para la programación
- genérica en D, ya que combinando *templates* que toman *strings* como
- parámetro en combinación con *string mixins* pueden hacerse toda clase de
- meta-programas.
+ T sumar(T: T*)(T x, T y) { return *x + *y; }
+ int x = 5, y = 6;
+ auto i = sumar(&x, &y); // i == 11
+ float v = 5.0f, w = 6.0f;
+ auto f = sumar(&v, &w); // f == 11.0f
- Ejemplo::
+ Tipos, valores (incluyendo *strings*) y *templates* como parámetros
+ Este es otro bloque de construcción importantísimo para la programación
+ genérica en D, ya que combinando *templates* que toman *strings* como
+ parámetro en combinación con *string mixins* pueden hacerse toda clase
+ de meta-programas.
- template hash(string s, uint so_far=0) {
- static if (s.length == 0)
- const hash = so_far;
- else
- const hash = hash!(s[1 .. length], so_far * 11 + s[0]);
- }
- string s = hash!("hola"); // calculado en tiempo de compilación
+ Ejemplo::
-Cantidad de parámetros variables para *templates*
- Esto permite implementar tuplas u otros algoritmos que inherentemente deben
- tomar una cantidad variable de parámetros en tiempo de compilación.
+ template hash(string s, uint so_far=0) {
+ static if (s.length == 0)
+ const hash = so_far;
+ else
+ const hash = hash!(s[1 .. length], so_far * 11 + s[0]);
+ }
+ string s = hash!("hola"); // calculado en tiempo de compilación
- Ejemplo::
+ Cantidad de parámetros variables para *templates*
+ Esta característica permite implementar tuplas y otros algoritmos que
+ inherentemente deben tomar una cantidad variable de parámetros en tiempo
+ de compilación.
- double sumar(T...)(T t) {
- double res = 0.0;
- foreach (x; t)
- res += x;
- return res;
- }
- double d = sumar(1, 2.0, 3.0f, 4l); // d == 10.0
+ Ejemplo::
+
+ double sumar(T...)(T t) {
+ double res = 0.0;
+ foreach (x; t)
+ res += x;
+ return res;
+ }
+ double d = sumar(1, 2.0, 3.0f, 4l); // d == 10.0
*CTFE* (*compile-time function execution*)
- si una función cumple ciertas reglas básicas (como por ejemplo no tener
+ Si una función cumple ciertas reglas básicas (como por ejemplo no tener
efectos colaterales) puede ser ejecutada en tiempo de compilación en vez de
tiempo de ejecución. Esto permite hacer algunos cálculos que no cambian de
ejecución en ejecución al momento de compilar, mejorando el rendimiento
static int x = factorial(5); // calculado en tiempo de compilación
int x = factorial(5); // calculado en tiempo de ejecución
- Esta característica es vital para evitar la duplicación de código.
+ Esta característica es muy importante para evitar la duplicación de código.
*Mixins*, incluyendo *string mixins*
- la palabra *mixin* tiene significados distintos en varios lenguajes de
+ La palabra *mixin* tiene significados distintos en varios lenguajes de
programación. En D_ *mixin* significa tomar una secuencia arbitraria de
declaraciones e insertarla en el contexto (*scope*) actual. Esto puede
realizarse a nivel global, en clases, estructuras o funciones. Esto sirve
Más información en http://www.digitalmars.com/d/1.0/mixin.html
Expresiones ``is``
- las *expresiones ``is``* permiten la compilación condicional basada en las
+ Las *expresiones ``is``* permiten la compilación condicional basada en las
características de un tipo.
Ejemplo::
D_ presenta muchas características de bajo nivel:
Compila a código de máquina nativo
- no es interpretado ni necesita una máquina virtual como otros lenguajes de
- más alto nivel como Java_, `C#`_, Python_, etc.
+ Los programas generados por D_ no son interpretados ni necesitan una
+ máquina virtual como otros lenguajes de más alto nivel como Java_, `C#`_,
+ Python_, etc.
-Provee acceso a *assembly*
- por lo tanto, acceso directo al *hardware* y la posibilidad de utilizar
- cualquier característica de éste que no esté disponible en el lenguaje.
+*Assembly* empotrado
+ Provee acceso directo al *hardware* y la posibilidad de utilizar cualquier
+ característica de éste que no esté disponible en el lenguaje.
Una ventaja sobre C y C++ es que el lenguaje *assembly* utilizado dentro de
D_ está especificado, por lo que se puede mantener la portabilidad entre
cambie de arquitectura, por supuesto).
``goto``
- al igual que C y C++, D_ provee la flexibilidad del uso de ``goto``.
+ Al igual que C y C++, D_ provee la flexibilidad del uso de ``goto``.
Compatibilidad con C
- soporta todos los tipos de C y es ABI [#abi]_ compatible con éste. Esto
+ Soporta todos los tipos de C y es ABI [#abi]_ compatible con éste. Esto
permite enlazar archivos objeto estándar de C y D_ en un mismo programa.
Además permite interoperar con C a través de ``extern (C)``.
printf("3 + 5 == %d\n", 3 + 5); // llama al printf de C
Manejo de memoria explícito
- permite asignar estructuras en el *stack* o en el *heap*, haciendo uso de
+ Permite asignar estructuras en el *stack* o en el *heap*, haciendo uso de
los servicios del sistema operativo o la biblioteca estándar de C.
Objetos y arreglos *livianos*
- por objetos *livianos* se entiende no-polimórficos. Es decir, un
+ Por objetos *livianos* se entiende no-polimórficos. Es decir, un
agrupamiento de variables análogo al ``struct`` de C, sin tabla virtual ni
otro tipo de *overhead*. Los arreglos *livianos* son arreglos estáticos
como en C, cuyo tamaño es fijo, también sin ningún tipo de *overhead* como
gettimeofday(&tv, null);
Rendimiento
- la :ref:`d_generic` permite realizar muchas optimizaciones ya que se
+ La :ref:`d_generic` permite realizar muchas optimizaciones ya que se
resuelve en tiempo de compilación y por lo tanto aumenta el rendimiento en
la ejecución.
de alto nivel, como Java_ y Python_, por ejemplo:
Manejo automático de memoria
- al igual que C/C++ y prácticamente cualquier lenguaje imperativo maneja
+ Al igual que C/C++ y prácticamente cualquier lenguaje imperativo maneja
automáticamente el *stack*, pero a diferencia de la mayoría de los
lenguajes de bajo nivel, D_ permite manejar el *heap* de manera automática
también a través de un *recolector de basura*.
Sistema de paquetes y módulos (similar a Java_ o Python_)
- un módulo es una unidad que agrupa clases, funciones y cualquier otra
+ Un módulo es una unidad que agrupa clases, funciones y cualquier otra
construcción de lenguaje. Un paquete es una agrupación de módulos. D_
asocia un módulo a un archivo fuente (y un archivo objeto cuando éste es
compilado) y un paquete a un directorio. A diferencia de C/C++ no necesita
f(); // ejecuta b.f()
Funciones y delegados
- las funciones pueden ser sobrecargadas (funciones con el mismo nombre pero
+ Las funciones pueden ser sobrecargadas (funciones con el mismo nombre pero
distinta cantidad o tipo de parámetros), pueden especificarse argumentos de
entrada, salida o entrada/salida, argumentos por omisión o argumentos
evaluados de forma perezosa (*lazy*). Además pueden tener una cantidad de
);
Arreglos *dinámicos* y arreglos asociativos
- los arreglos *dinámicos* son arreglos de longitud variable manejados
+ Los arreglos *dinámicos* son arreglos de longitud variable manejados
automáticamente por el lenguaje (análogos al ``std::vector`` de C++).
Soportan concatenación (a través del operador ``~``), rebanado o *slicing*
(a través del operador ``[x..y]``) y chequeo de límites (*bound checking*).
agenda["Pepe"] = 5555_1234;
*Strings*
- al igual que los delegados y arreglos dinámicos y asociativos, los
+ Al igual que los delegados y arreglos dinámicos y asociativos, los
*strings* son ciudadanos de primera clase, teniendo forma literal y siendo
codificados en UTF-8/16/32. Son un caso particular de arreglo dinámico y es
posible utilizarlos en sentencias ``switch``/``case``.
}
``typedef`` y ``alias``
- el primero define un nuevo tipo basado en otro. A diferencia de C/C++ el
+ El primero define un nuevo tipo basado en otro. A diferencia de C/C++ el
tipo original no puede ser implícitamente convertido al tipo nuevo (excepto
valores literales), pero la conversión es válida en el otro sentido
(similar a los ``enum`` en C++). Por el contrario, ``alias`` es análogo al
características más salientes se encuentran:
Objetos *pesados*
- objetos polimórficos como los de cualquier lenguaje con orientación real
+ Objetos polimórficos como los de cualquier lenguaje con orientación real
a objetos. Estos objetos poseen una tabla virtual para despacho dinámico,
todos los métodos son virtuales a menos que se indique lo contrario
y tienen semántica de referencia [#drefsem]_. Estos objetos tienen un
misma interfaz.
Sobrecarga de operadores
- la sobrecarga de operadores permite que un objeto tenga una sintaxis
+ La sobrecarga de operadores permite que un objeto tenga una sintaxis
similar a un tipo de dato nativo. Esto es muy importante además para la
programación genérica.
Clases anidadas
- al igual que C (con respecto a ``struct``) y C++, pueden anidarse clases
+ Al igual que C (con respecto a ``struct``) y C++, pueden anidarse clases
dentro de clases. D_ sin embargo provee la posibilidad de acceder
a atributos de la instancia exterior desde la anidada.
Propiedades (*properties*)
- en D_ se refiere a funciones miembro que pueden ser tratadas
+ En D_ se refiere a funciones miembro que pueden ser tratadas
sintácticamente como campos de esa clase/estructura.
Ejemplo::
*properties* predefinidos, por ejemplo:
``sizeof``
- tamaño ocupado en memoria (ejemplo: ``int.sizeof`` -> 4).
+ Tamaño ocupado en memoria (ejemplo: ``int.sizeof`` -> 4).
``init``
- valor de inicialización por omisión (ejemplo: ``float.init`` -> *NaN*
+ Valor de inicialización por omisión (ejemplo: ``float.init`` -> *NaN*
[#dnan]_).
.. [#dnan] Del inglés *Not A Number*, es un valor especial que indica que
estamos ante un valor inválido.
``stringof``
- representación textual del símbolo o expresión (ejemplo:
+ Representación textual del símbolo o expresión (ejemplo:
``(1+2).stringof`` -> ``"1 + 2"``).
``mangleof``
- representación textual del tipo *mutilado* [#dmangle]_.
+ Representación textual del tipo *mutilado* [#dmangle]_.
.. [#dmangle] *Name mangling* es el nombre dado comunmente a una técnica
necesaria para poder sobrecargar nombres de símbolos. Consiste en
tengan nombres distintos.
``alignof``
- alineación de una estructura o tipo.
+ Alineación de una estructura o tipo.
Estos son solo los *properties* predefinidos para todos los tipos, pero hay
una cantidad considerable de *properties* extra para cada tipo.
silenciosamente sin ser detectados.
``assert``
- es una condición que debe cumplirse siempre en un programa, como un chequeo
+ Es una condición que debe cumplirse siempre en un programa, como un chequeo
de integridad. Esto es muy utilizado en C/C++, donde ``assert()`` es una
*macro* que solo se compila cuando la *macro* ``NDEBUG`` no está definida.
Esto permite eliminar los chequeos de integridad del programa, que pueden
assert (f.ok());
Diseño por contrato
- el diseño por contrato es un concepto introducido por el lenguaje Eiffel_
+ El diseño por contrato es un concepto introducido por el lenguaje Eiffel_
a mediados/finales de los '80. Se trata de incorporar en el lenguaje las
herramientas para poder aplicar verificaciones formales a las interfaces de
los programas.
Más información en http://www.digitalmars.com/d/1.0/dbc.html
Pruebas unitarias
- es posible incluir pequeñas pruebas unitarias en el lenguaje. Éstas son
+ Es posible incluir pequeñas pruebas unitarias en el lenguaje. Éstas son
ejecutadas (cuando no se compila en modo *release*) al comenzar el
programa, antes de que la función ``main()``.
}
Orden de construcción estática
- a diferencia de C++, D_ garantiza el orden de inicialización de los
+ A diferencia de C++, D_ garantiza el orden de inicialización de los
módulos. Si bien en C++ no hay módulos si no unidades de compilación, es
posible que se ejecute código antes del ``main()`` en C++, si hay, por
ejemplo, instancias globales con un constructor definido. C++ no garantiza
los módulos.
Inicialización garantizada
- todas las variables son inicializadas por el lenguaje (a menos que el
+ Todas las variables son inicializadas por el lenguaje (a menos que el
usuario pida explícitamente que no lo sean). Siempre que sea posible se
elijen valores de inicialización que permitan saber al programador que la
variable no fue inicializada explícitamente, de manera de poder detectar
long l = void; // NO inicializado (explícitamente)
*RAII* (*Resource Adquisition Is Initialization*)
- es una técnica muy utilizada en C++ que consiste en reservar recursos por
+ Es una técnica muy utilizada en C++ que consiste en reservar recursos por
medio de la construcción de un objeto y liberarlos cuando se libera éste.
Al llamarse al destructor de manera automática cuando se sale del *scope*,
se asegura que el recurso será liberado también.
} // en este punto se llama al destructor de archivo
Guardias de bloque (*scope guards*)
- además de poder limitar la vida de una instancia a un *scope*, es posible
+ Además de poder limitar la vida de una instancia a un *scope*, es posible
especificar un bloque de código arbitrario a ejecutar al abandonar un
*scope*, ya sea cuando se sale del *scope* normalmente o por una falla.
acciones a ejecutar al finalizar el *scope*.
Primitivas de sincronización de hilos
- la programación multi-hilo está directamente soportada por el lenguaje,
+ La programación multi-hilo está directamente soportada por el lenguaje,
y se provee una primitiva de sincronización al igual que Java_. La palabra
reservada ``synchronized`` puede aparecer como modificador de métodos (en
cuyo caso se utiliza un *lock* por clase para sincronizar) o como una
Cada *pool* tiene la siguiente información asociada:
*number_of_pages*
- cantidad de páginas que tiene. Esta cantidad es fija en toda la vida de un
+ Cantidad de páginas que tiene. Esta cantidad es fija en toda la vida de un
*pool*.
*pages*
- bloque de memoria contiguo de tamaño ``PAGE_SIZE * number_of_pages``
+ Bloque de memoria contiguo de tamaño ``PAGE_SIZE * number_of_pages``
(siendo ``PAGE_SIZE`` el tamaño de página, que normalmente son 4096 bytes).
significado especial:
``FREE``
- indica que la página está completamente libre y que la página está
+ Indica que la página está completamente libre y que la página está
disponible para albergar cualquier tamaño de bloque que sea necesario (pero
una vez que se le asignó un nuevo tamaño de bloque ya no puede ser cambiado
hasta que la página vuelva a liberarse por completo).
``CONTINUATION``
- indica que esta página es la continuación de un objeto grande (es decir,
+ Indica que esta página es la continuación de un objeto grande (es decir,
que ocupa una o más páginas). Luego se presentan más detalles sobre objetos
grandes.
Cada bloque tiene asociados varios atributos:
*mark*
- utilizado en la fase de :ref:`marcado <dgc_algo_mark>`, indica que un nodo
+ Utilizado en la fase de :ref:`marcado <dgc_algo_mark>`, indica que un nodo
ya fue visitado (serían las celdas *negras* en la :ref:`abstracción
tricolor <gc_intro_tricolor>`).
*scan*
- utilizado también en la fase de :ref:`marcado <dgc_algo_mark>`, indica que
+ Utilizado también en la fase de :ref:`marcado <dgc_algo_mark>`, indica que
una celda visitada todavía tiene *hijas* sin marcar (serían las celdas
*grises* en la :ref:`abstracción tricolor <gc_intro_tricolor>`).
*free*
- indica que el bloque está libre (no está siendo utilizado por ningún objeto
+ Indica que el bloque está libre (no está siendo utilizado por ningún objeto
*vivo*). Esto es necesario solo por la forma en la que realiza el
:ref:`marcado <dgc_algo_mark>` y :ref:`barrido <dgc_algo_sweep>` en el
:ref:`algoritmo actual <dgc_algo>` (las celdas con el atributo este
atributo son tomadas como *basura* aunque estén marcadas con *mark*).
*final*
- indica que el bloque contiene un objeto que tiene un destructor (que debe
+ Indica que el bloque contiene un objeto que tiene un destructor (que debe
ser llamado cuando la celda pasa de *viva* a *basura*).
*noscan*
- indica que el bloque contiene un objeto que no tiene punteros y por lo
+ Indica que el bloque contiene un objeto que no tiene punteros y por lo
tanto no debe ser marcado de forma conservativa (no tiene *hijas*).
Raíces definidas por el usuario
*roots* (*nroots*, *rootdim*)
- arreglo variable de punteros simples que son tomados como raíces
+ Arreglo variable de punteros simples que son tomados como raíces
provistas por el usuario.
*ranges* (*nranges*, *rangedim*)
- arreglo variable de rangos de memoria que deben ser revisados (de forma
+ Arreglo variable de rangos de memoria que deben ser revisados (de forma
conservativa) como raíces provistas por el usuario. Un rango es una
estructura con dos punteros: ``pbot`` y ``ptop``. Toda la memoria entre
estos dos punteros se toma, palabra por palabra, como una raíz del
Estado interno del recolector
*anychanges*
- variable que indica si en la fase de marcado se encontraron nuevas
+ Variable que indica si en la fase de marcado se encontraron nuevas
celdas con punteros que deban ser visitados. Otra forma de verlo es como
un indicador de si el conjunto de celdas *grises* está vacío luego de
una iteración de marcado (utilizando la :ref:`abstracción tricolor
presentada en :ref:`dgc_algo_mark`.
*inited*
- indica si el recolector fue inicializado.
+ Indica si el recolector fue inicializado.
*stackBottom*
- puntero a la base del *stack* (asumiendo que el stack crece hacia arriba).
+ Puntero a la base del *stack* (asumiendo que el stack crece hacia arriba).
Se utiliza para saber por donde comenzar a visitar el *stack* de forma
conservativa, tomándolo con una raíz del recolector.
*Pools* (*pooltable*, *npools*)
- arreglo variable de punteros a estructuras ``Pool`` (ver más adelante).
+ Arreglo variable de punteros a estructuras ``Pool`` (ver más adelante).
Este arreglo se mantiene siempre ordenado de menor a mayor según la
dirección de memoria de la primera página que almacena.
*bucket*
- listas de libres. Es un arreglo de estructuras ``List`` utilizadas para
+ Listas de libres. Es un arreglo de estructuras ``List`` utilizadas para
guardar la listas de libres de todos los tamaños de bloques posibles (ver
más adelante).
Atributos que cambian el comportamiento
*noStack*
- indica que no debe tomarse al *stack* como raíz del recolector. Esto es
+ Indica que no debe tomarse al *stack* como raíz del recolector. Esto es
muy poco seguro y no debería ser utilizado nunca, salvo casos
extremadamente excepcionales.
*log*
- indica si se debe guardar un registro de la actividad del recolector. Es
+ Indica si se debe guardar un registro de la actividad del recolector. Es
utilizado principalmente para depuración.
*disabled*
- indica que no se deben realizar recolecciones implícitamente. Si al
+ Indica que no se deben realizar recolecciones implícitamente. Si al
tratar de asignar memoria no se puede hallar celdas libres en el *heap*
del recolector, se pide más memoria al sistema operativo sin correr una
recolección para intentar recuperar espacio. Esto es particularmente
Optimizaciones
*p_cache*, *size_cache*
- obtener el tamaño de un bloque dado un puntero es una tarea costosa
+ Obtener el tamaño de un bloque dado un puntero es una tarea costosa
y común. Para evitarla en casos donde se calcula de forma sucesiva el
tamaño del mismo bloque (como puede ocurrir al concatenar arreglos
dinámicos) se guarda el último calculado en estas variables a modo de
*caché*.
*minAddr*, *maxAddr*
- punteros al principio y fin del *heap*. Pueden haber *huecos* entre
+ Punteros al principio y fin del *heap*. Pueden haber *huecos* entre
estos dos punteros que no pertenezcan al *heap* pero siempre se cumple
que si un puntero apunta al *heap* debe estar en este rango. Esto es
útil para hacer un cálculo rápido para descartar punteros que fueron
+--------+--------+-----+--------+-----+-------------------+
*baseAddr* y *topAddr*
- punteros al comienzo y fin de la memoria que almacena todas las páginas del
+ Punteros al comienzo y fin de la memoria que almacena todas las páginas del
*pool* (*baseAddr* es análogo al atributo *pages* utilizado en las
secciones anteriores para mayor claridad).
*mark*, *scan*, *freebits*, *finals*, *noscan*
- conjunto de bits (*bitsets*) para almacenar los indicadores descriptos en
+ Conjunto de bits (*bitsets*) para almacenar los indicadores descriptos en
:ref:`dgc_org` para todos los bloques de todas las páginas del *pool*.
*freebits* es análogo a *free* y *finals* a *final* en los atributos
descriptos en las secciones anteriores.
*npages*
- cantidad de páginas que contiene este *pool* (fue nombrado
+ Cantidad de páginas que contiene este *pool* (fue nombrado
*number_of_pages* en las secciones anteriores para mayor claridad).
*ncommitted*
- cantidad de páginas *encomendadas* al sistema operativo (*committed* en
+ Cantidad de páginas *encomendadas* al sistema operativo (*committed* en
inglés). Este atributo no se mencionó anteriormente porque el manejo de
páginas encomendadas le agrega una complejidad bastante notable al
recolector y es solo una optimización para un sistema operativo en
particular (Microsoft Windows).
*pagetable*
- arreglo de indicadores de tamaño de bloque de cada página de este *pool*.
+ Arreglo de indicadores de tamaño de bloque de cada página de este *pool*.
Los indicadores válidos son ``B_16`` a ``B_2048`` (pasando por los valores
posibles de bloque mencionados anteriormente, todos con el prefijo
"``B_``"), ``B_PAGE``, ``B_PAGEPLUS`` (análogo a ``CONTINUATION``),
Inicialización y terminación
*initialize()*
- inicializa las estructuras internas del recolector para que pueda ser
+ Inicializa las estructuras internas del recolector para que pueda ser
utilizado. Esta función la llama la biblioteca *runtime* antes de que el
programa comience a correr.
*Dtor()*
- libera todas las estructuras que utiliza el recolector.
+ Libera todas las estructuras que utiliza el recolector.
Manipulación de raíces definidas por el usuario
*addRoot(p)*, *removeRoot(p)*, *rootIter(dg)*
- agrega, remueve e itera sobre las raíces simples definidas por el
+ Agrega, remueve e itera sobre las raíces simples definidas por el
usuario.
*addRange(pbot, ptop)*, *remove range(pbot)*, *rangeIter(dg)*
- agrega, remueve e itera sobre los rangos de raíces definidas por el
+ Agrega, remueve e itera sobre los rangos de raíces definidas por el
usuario.
Manipulación de indicadores
*getBits(pool, biti)*
- obtiene los indicadores especificados para el bloque de índice ``biti``
+ Obtiene los indicadores especificados para el bloque de índice ``biti``
en el *pool* ``pool``.
*setBits(pool, biti, mask)*
- establece los indicadores especificados en ``mask`` para el bloque de
+ Establece los indicadores especificados en ``mask`` para el bloque de
índice ``biti`` en el *pool* ``pool``.
*clrBits(pool, biti, mask)*
- limpia los indicadores especificados en ``mask`` para el bloque de
+ Limpia los indicadores especificados en ``mask`` para el bloque de
índice ``biti`` en el *pool* ``pool``.
Cada bloque (*bin* en la terminología de la implementación del recolector)
compuesta por la conjunción de los siguientes valores:
*FINALIZE*
- el objeto almacenado en el bloque tiene un destructor (indicador
+ El objeto almacenado en el bloque tiene un destructor (indicador
*finals*).
*NO_SCAN*
- el objeto almacenado en el bloque no contiene punteros (indicador
+ El objeto almacenado en el bloque no contiene punteros (indicador
*noscan*).
*NO_MOVE*
- el objeto almacenado en el bloque no debe ser movido [#dgcmove]_.
+ El objeto almacenado en el bloque no debe ser movido [#dgcmove]_.
.. [#dgcmove] Si bien el recolector actual no tiene la capacidad de mover
objetos, la interfaz del recolector hacer que sea posible una
Búsquedas
*findPool(p)*
- busca el *pool* al que pertenece el objeto apuntado por ``p``.
+ Busca el *pool* al que pertenece el objeto apuntado por ``p``.
*findBase(p)*
- busca la dirección base (el inicio) del bloque apuntado por ``p``
+ Busca la dirección base (el inicio) del bloque apuntado por ``p``
(``find_block()`` según la sección :ref:`dgc_algo_mark`).
*findSize(p)*
- busca el tamaño del bloque apuntado por ``p``.
+ Busca el tamaño del bloque apuntado por ``p``.
*getInfo(p)*
- obtiene información sobre el bloque apuntado por ``p``. Dicha
+ Obtiene información sobre el bloque apuntado por ``p``. Dicha
información se retorna en una estructura ``BlkInfo`` que contiene los
siguientes atributos: ``base`` (dirección del inicio del bloque),
``size`` (tamaño del bloque) y ``attr`` (atributos o indicadores del
bloque, los que se pueden obtener con ``getBits()``).
*findBin(size)*
- calcula el tamaño de bloque más pequeño que pueda contener un objeto de
+ Calcula el tamaño de bloque más pequeño que pueda contener un objeto de
tamaño ``size`` (``find_block_size()`` según lo visto en
:ref:`dgc_algo_alloc`).
Asignación de memoria
*reserve(size)*
- reserva un nuevo *pool* de al menos ``size`` bytes. El algoritmo nunca
+ Reserva un nuevo *pool* de al menos ``size`` bytes. El algoritmo nunca
crea un *pool* con menos de 256 páginas (es decir, 1 MiB).
*minimize()*
- minimiza el uso de la memoria retornando *pools* sin páginas usadas al
+ Minimiza el uso de la memoria retornando *pools* sin páginas usadas al
sistema operativo.
*newPool(n)*
- reserva un nuevo *pool* con al menos ``n`` páginas. Junto con
+ Reserva un nuevo *pool* con al menos ``n`` páginas. Junto con
``Pool.initialize()`` es análoga a ``new_pool()``, solo que esta función
siempre incrementa el número de páginas a, al menos, 256 páginas (es
decir, los *pools* son siempre mayores a 1 MiB). Si la cantidad de
*pools* de 8 MiB o la cantidad pedida, si ésta es mayor.
*Pool.initialize(n_pages)*
- inicializa un nuevo *pool* de memoria. Junto con ``newPool()`` es
+ Inicializa un nuevo *pool* de memoria. Junto con ``newPool()`` es
análoga a ``new_pool()``. Mientras ``newPool()`` es la encargada de
calcular la cantidad de páginas y crear el objeto *pool*, esta función
es la que pide la memoria al sistema operativo. Además inicializa los
``finals`` de todo el *pool*.
*allocPage(bin)*
- asigna a una página libre el tamaño de bloque ``bin`` y enlaza los
+ Asigna a una página libre el tamaño de bloque ``bin`` y enlaza los
nuevos bloques libres a la lista de libres correspondiente (análogo
a ``assign_page()``).
a ``find_pages(n)``).
*malloc(size, bits)*
- asigna memoria para un objeto de tamaño ``size`` bytes. Análoga al
+ Asigna memoria para un objeto de tamaño ``size`` bytes. Análoga al
algoritmo ``new(size, attr)`` presentado, excepto que introduce además
un caché para no recalcular el tamaño de bloque necesario si se realizan
múltiples asignaciones consecutivas de objetos del mismo tamaño y que la
asignación de objetos pequeños no está separada en una función aparte.
*bigAlloc(size)*
- asigna un objeto grande (análogo a ``new_big()``). La implementación es
+ Asigna un objeto grande (análogo a ``new_big()``). La implementación es
mucho más compleja que la presentada en ``new_big()``, pero la semántica
es la misma. La única diferencia es que esta función aprovecha que
``fullcollectshell()`` / ``fullcollect()`` retornan la cantidad de
objeto grande y pasar directamente a crear un nuevo *pool*.
*free(p)*
- libera la memoria apuntada por ``p`` (análoga a ``delete()`` de la
+ Libera la memoria apuntada por ``p`` (análoga a ``delete()`` de la
sección anterior).
Recordar que la ``pooltable`` siempre se mantiene ordenada según la
Recolección
*mark(pbot, ptop)*
- marca un rango de memoria. Este método es análogo al ``mark_range()``
+ Marca un rango de memoria. Este método es análogo al ``mark_range()``
presentado en la sección :ref:`dgc_algo_mark`.
*fullcollectshell()*
- guarda los registros en el *stack* y llama a ``fullcollect()``. El
+ Guarda los registros en el *stack* y llama a ``fullcollect()``. El
algoritmo presentado en :ref:`dgc_algo_mark` es simbólico, ya que si los
registros se apilaran en el *stack* dentro de otra función, al salir de
esta se volverían a des-apilar, por lo tanto debe ser hecho en la misma
caso).
*fullcollect(stackTop)*
- realiza la recolección de basura. Es análoga a ``collect()`` pero es
+ Realiza la recolección de basura. Es análoga a ``collect()`` pero es
considerablemente menos modular, todos los pasos se hacen directamente
en esta función: marcado del *root set*, marcado iterativo del *heap*,
barrido y reconstrucción de la lista de libres. Además devuelve la
mejorarse:
Listas de libres
- hay 12 listas de libres, como para guardar bloques de tamaño de ``B_16``
+ Hay 12 listas de libres, como para guardar bloques de tamaño de ``B_16``
a ``B_2048``, ``B_PAGE``, ``B_PAGEPLUS``, ``B_UNCOMMITTED`` y ``B_FREE``;
sin embargo solo tienen sentido los bloques de tamaño ``B_16``
a ``B_2048``, por lo que 4 de esas listas no se utilizan.
Conjuntos de bits para indicadores
- los indicadores para la fase de marcado y otras propiedades de un bloque
+ Los indicadores para la fase de marcado y otras propiedades de un bloque
son almacenados en conjuntos de bits que almacenan los indicadores de todos
los bloques de un *pool*. Si bien se ha mencionado esto como una ventaja,
hay lugar todavía como para algunas mejoras. Como un *pool* tiene páginas
actualmente). Esto es propenso a errores y difícil de mantener.
Uso de señales
- el recolector actual utiliza las señales del sistema operativo ``SIGUSR1``
+ El recolector actual utiliza las señales del sistema operativo ``SIGUSR1``
y ``SIGUSR2`` para pausar y reanudar los hilos respectivamente. Esto
puede traer inconvenientes a usuarios que desean utilizar estas
señales en sus programas (o peor aún, si interactúan con bibliotecas
de C que hacen uso de estas señales) [NGD5821]_.
Marcado iterativo
- si bien esto se mencionó como algo bueno del recolector actual, es un
+ Si bien esto se mencionó como algo bueno del recolector actual, es un
compromiso entre tiempo y espacio, y puede ser interesante analizar otros
métodos para evitar la recursión que no requieran tantas pasadas sobre el
*heap*.
Más formalmente, Definimos:
*Camino*
- secuencia de vértices tal que cada uno de los vértices tiene una arista al
- próximo vértice en la secuencia. Todo camino finito tiene un *vértice
- inicial* y un *vértice final* (llamados en conjunto *vértices terminales*).
- Cualquier vértice no terminal es denominado *vértice interior*.
+ Es una secuencia de vértices tal que cada uno de los vértices tiene una
+ arista al próximo vértice en la secuencia. Todo camino finito tiene un
+ *vértice inicial* y un *vértice final* (llamados en conjunto *vértices
+ terminales*). Cualquier vértice no terminal es denominado *vértice
+ interior*.
.. math::
interior* puede ser un *vértice terminal*.
*Conexión*
- decimos que :math:`M` está *conectado* a :math:`N` si y sólo si existe un
+ Decimos que :math:`M` está *conectado* a :math:`N` si y sólo si existe un
camino de :math:`M` a :math:`N`.
.. math::
M \mapsto N \Longleftrightarrow \exists \underset{M \to N}{C} \in G
*Live set*
- el conjunto de celdas *vivas* está dado por todos los vértices (:math:`v`)
- del grafo para los cuales existe una raíz en el *root set* que esté
- conectada a él.
+ Es el conjunto de celdas *vivas* está dado por todos los vértices
+ (:math:`v`) del grafo para los cuales existe una raíz en el *root set* que
+ esté conectada a él.
.. math::
\right\rbrace
*Basura*
- la basura, o celdas *muertas*, quedan determinadas entonces por todas las
+ La basura, o celdas *muertas*, quedan determinadas entonces por todas las
celdas del *heap* que no son parte del *live set*.
.. math::
Servicios utilizados por el recolector son los siguientes:
:math:`alloc() \to cell`
- obtiene una nueva celda de memoria. El mecanismo por el cual se obtiene la
+ Obtiene una nueva celda de memoria. El mecanismo por el cual se obtiene la
celda es indistinto para esta sección, puede ser de una lista libre, puede
ser de un administrador de memoria de más bajo nivel provisto por el
sistema operativo o la biblioteca estándar de C (``malloc()``), etc. Cómo
puede ser fácilmente relajada (en los recolectores que la tienen).
:math:`free(cell)`
- libera una celda que ya no va a ser utilizada. La celda liberada debe haber
+ Libera una celda que ya no va a ser utilizada. La celda liberada debe haber
sido obtenida mediante ``alloc()``.
Y los servicios básicos proporcionados por el recolector son los siguientes:
:math:`new() \to cell`
- obtiene una celda de memoria para ser utilizada por el programa.
+ Obtiene una celda de memoria para ser utilizada por el programa.
:math:`update(ref, cell)`
- notifica al recolector que la referencia :math:`ref` ahora apunta
+ Notifica al recolector que la referencia :math:`ref` ahora apunta
a :math:`cell`. Visto más formalmente, sería análogo a decir que hubo un
cambio en la conectividad del grafo: la arista :math:`src \to old` cambia
por :math:`src \to new` (donde :math:`src` es la celda que contiene la
:math:`src \to old`.
:math:`del(cell)`
- este servicio, según el algoritmo, puede ser utilizado para informar un
+ Este servicio, según el algoritmo, puede ser utilizado para informar un
cambio en la conectividad del grafo, la eliminación de una arista (análogo
a :math:`update(ref, null)` pero sin proporcionar información sobre la
arista a eliminar). Esto es generalmente útil solo en :ref:`conteo de
\big\rbrace`.
:math:`collect()`
- indica al recolector que debe hacer un análisis del grafo de conectividad
- en busca de *basura*. Generalmente este servicio es invocado por el propio
- recolector cuando no hay más celdas reciclables.
+ Este servicio indica al recolector que debe hacer un análisis del grafo de
+ conectividad en busca de *basura*. Generalmente este servicio es invocado
+ por el propio recolector cuando no hay más celdas reciclables.
No todos los servicios son implementados por todos los recolectores, pero son
lo suficientemente comunes como para describirlos de forma general en esta
:sorted:
*mutator*
- parte del programa que realiza cambios al grafo de conectividad.
+ Parte del programa que realiza cambios al grafo de conectividad.
recolector
- parte del programa que recupera celdas *muertas* (no realiza cambios en
+ 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
+ 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
+ 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
+ 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
:ref:`gc_intro_mark`.
abstracción tricolor
- método para marcar todas las celdas de un grafo que sea accesibles de
+ 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
:ref:`gc_intro_tricolor`.
celda
- porción contigua de memoria destinada a almacenar un objeto o estructura
+ 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
+ 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
+ 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
+ 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
+ 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
+ Celda que no lleva ninguna (o muy pocas) recolecciones sin ser
recolectada.
celda *vieja*
- celda que lleva varias recolecciones sin ser recolectada.
+ Celda que lleva varias recolecciones sin ser recolectada.
celda *viva*
- celda de memoria que puede ser accedida transitivamente a través del
+ 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
+ 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
+ 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
+ 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*.
+ Conjunto de todas las celdas *vivas*.
palabra
- tamaño de dato característico de un procesador que permite almacenar una
+ 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
+ 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
+ Ã\81rea 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
+ Ã\81rea 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.
+ Puntero que almacena una dirección de memoria inválida (*puntero
+ colgante* en castellano).
localidad de referencia
- medida en que los accesos sucesivos de memoria cercana espacialmente son
+ 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
+ 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.
+ Frecuencia con la que el caché puede responder con éxito.
*cache*
- memoria pequeña (por ser típicamente muy costosa) pero muy veloz.
+ 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
+ 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
+ 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.
+ Ver referencia débil.
ciclo
- un conjunto de celdas que están referenciadas entre sí de forma tal que
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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.
+ 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
+ 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
+ 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
+ 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*.
+ Ver *desbordamiento de pila*.
desbordamiento de pila
- agotamiento del *stack*.
+ Agotamiento de la memoria del *stack*.
*bitset*
- ver conjunto de bits.
+ Ver conjunto de bits.
conjunto de bits
- estructura de datos que sirve para almacenar un conjunto de indicadores
+ 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
realiza de forma eficiente utilizando máscaras.
*system programming*
- se refiere a programación de bajo nivel. En general involucra
+ 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.
+ Análisis sintáctico de un lenguaje estructurado.
*context-free grammar*
- gramática que no depende del contexto (es decir, de información
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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.
+ 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 en tiempo de ejecución.
verificación de tipos
- forma en la que un sistema de tipos asigna tipos y verifica sus
+ 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
+ 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
+ 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.
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ Acto de verificar la presencia de un constituyente sintáctico de un
patrón dado.
*activation record*
- ver *stack frame*.
+ Ver *stack frame*.
*stack frame*
- estructura de datos dependiente de la arquitectura que contiene
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
(*RTTI*).
*RTTI*
- abreviatura del inglés *Run-Time Type Identification*, es la información
+ 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*).
+ 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,
+ 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
+ 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
+ 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
+ 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,
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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`.
+ 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*
+ 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
+ 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
+ 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
+ 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
+ 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
+ Recolección que detiene todos los hilos del *mutator*. Ver
:ref:`gc_concurrent`.
*stop-the-world*
- ver *recolección 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ 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
+ Banco de pruebas utilizado para medir y comparar el rendimiento de un
programa, algoritmo o proceso en general.
BNF
projects / z.facultad / 75.00 / informe.git / commitdiff