From: Leandro Lucarella Date: Sat, 16 Oct 2010 01:40:49 +0000 (-0300) Subject: Comenzar listas de definición con mayúscula X-Git-Tag: borrador-jurado~17 X-Git-Url: https://git.llucax.com/z.facultad/75.00/informe.git/commitdiff_plain/6eef2aaa7b3487663baa7e365eadb948ad2f1efd Comenzar listas de definición con mayúscula --- diff --git a/source/d.rst b/source/d.rst index 6b66605..ceb8a2a 100644 --- a/source/d.rst +++ b/source/d.rst @@ -185,9 +185,9 @@ D_ provee las siguientes herramientas para realizar programación genérica 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:: @@ -197,8 +197,8 @@ y meta-programación: 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:: @@ -219,7 +219,7 @@ Inferencia de tipos básica implícita y explícita (mediante ``typeof``) 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``. @@ -231,7 +231,7 @@ Iteración sobre colecciones (``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 @@ -262,70 +262,74 @@ Iteración sobre colecciones (``foreach``) 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 @@ -343,10 +347,10 @@ Cantidad de parámetros variables para *templates* 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 @@ -388,7 +392,7 @@ Cantidad de parámetros variables para *templates* 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:: @@ -419,12 +423,13 @@ el lenguaje de bajo nivel más popular, seguido por C++. 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 @@ -432,10 +437,10 @@ Provee acceso a *assembly* 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)``. @@ -448,11 +453,11 @@ Compatibilidad con 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 @@ -481,7 +486,7 @@ Objetos y arreglos *livianos* 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. @@ -520,13 +525,13 @@ productividad de los programadores. D_ adopta herramientas de muchos lenguajes 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 @@ -555,7 +560,7 @@ Sistema de paquetes y módulos (similar a Java_ o Python_) 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 @@ -602,7 +607,7 @@ Funciones y delegados ); 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*). @@ -621,7 +626,7 @@ Arreglos *dinámicos* y arreglos asociativos 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``. @@ -638,7 +643,7 @@ Arreglos *dinámicos* y arreglos asociativos } ``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 @@ -686,7 +691,7 @@ herramientas para soportar este paradigma de forma confiable. Entre las 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 @@ -738,12 +743,12 @@ Interfaces 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. @@ -778,7 +783,7 @@ Clases anidadas 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:: @@ -796,21 +801,21 @@ Propiedades (*properties*) *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 @@ -820,7 +825,7 @@ Propiedades (*properties*) 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. @@ -848,7 +853,7 @@ Excepciones 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 @@ -864,7 +869,7 @@ Excepciones 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. @@ -914,7 +919,7 @@ Diseño por contrato 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()``. @@ -928,7 +933,7 @@ Pruebas unitarias } 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 @@ -937,7 +942,7 @@ Orden de construcción estática 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 @@ -952,7 +957,7 @@ Inicialización garantizada 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. @@ -978,7 +983,7 @@ Inicialización garantizada } // 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. @@ -1005,7 +1010,7 @@ Guardias de bloque (*scope guards*) 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 diff --git a/source/dgc.rst b/source/dgc.rst index 370b664..98e260b 100644 --- a/source/dgc.rst +++ b/source/dgc.rst @@ -338,11 +338,11 @@ Atributos de *pool* 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). @@ -357,13 +357,13 @@ Una página siempre almacena bloques del mismo tamaño, que pueden ser 16, 32, 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. @@ -376,28 +376,28 @@ Atributos de bloque Cada bloque tiene asociados varios atributos: *mark* - utilizado en la fase de :ref:`marcado `, indica que un nodo + Utilizado en la fase de :ref:`marcado `, indica que un nodo ya fue visitado (serían las celdas *negras* en la :ref:`abstracción tricolor `). *scan* - utilizado también en la fase de :ref:`marcado `, indica que + Utilizado también en la fase de :ref:`marcado `, indica que una celda visitada todavía tiene *hijas* sin marcar (serían las celdas *grises* en la :ref:`abstracción 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 ` y :ref:`barrido ` en el :ref:`algoritmo actual ` (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*). @@ -967,11 +967,11 @@ facilitar la comprensión): 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 @@ -979,7 +979,7 @@ Raíces definidas por el usuario 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 @@ -987,35 +987,35 @@ Estado interno del recolector 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 @@ -1025,14 +1025,14 @@ Atributos que cambian el comportamiento 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 @@ -1081,29 +1081,29 @@ La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura +--------+--------+-----+--------+-----+-------------------+ *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``), @@ -1156,33 +1156,33 @@ para facilitar la comprensión. Los siguientes son métodos de la estructura 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) @@ -1194,15 +1194,15 @@ Manipulación de indicadores 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 @@ -1212,38 +1212,38 @@ Manipulación de indicadores 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 @@ -1255,7 +1255,7 @@ Asignación de memoria *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 @@ -1265,7 +1265,7 @@ Asignación de memoria ``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()``). @@ -1274,14 +1274,14 @@ Asignación de memoria 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 @@ -1290,7 +1290,7 @@ Asignación de memoria 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 @@ -1298,11 +1298,11 @@ Asignación de memoria 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 @@ -1310,7 +1310,7 @@ Recolección 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 @@ -1784,13 +1784,13 @@ Finalmente hay varios detalles en la implementación actual que podrían 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 @@ -1812,14 +1812,14 @@ Repetición de código 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*. diff --git a/source/gc.rst b/source/gc.rst index c1c9cb1..585baa1 100644 --- a/source/gc.rst +++ b/source/gc.rst @@ -196,10 +196,11 @@ fueron visitados componen el *live set*; el resto de los vértices son 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:: @@ -214,7 +215,7 @@ Más formalmente, Definimos: 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:: @@ -222,9 +223,9 @@ Más formalmente, Definimos: 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:: @@ -233,7 +234,7 @@ Más formalmente, Definimos: \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:: @@ -647,7 +648,7 @@ recolectores a lo largo de este documento. 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 @@ -660,16 +661,16 @@ Servicios utilizados por el recolector son los siguientes: 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 @@ -679,7 +680,7 @@ Y los servicios básicos proporcionados por el recolector son los siguientes: :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 @@ -690,9 +691,9 @@ Y los servicios básicos proporcionados por el recolector son los siguientes: \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 diff --git a/source/glosario.rst b/source/glosario.rst index f0f9eb1..8133ba5 100644 --- a/source/glosario.rst +++ b/source/glosario.rst @@ -6,24 +6,24 @@ Glosario :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 @@ -31,7 +31,7 @@ Glosario :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 @@ -40,182 +40,182 @@ Glosario :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 + Área de memoria que en la cual se asigna y liberan celdas dinámicamente (durante la ejecución del programa). *stack* - área de memoria organizada en forma de pila donde se almacenan + Área de memoria organizada en forma de pila donde se almacenan típicamente las variables locales, parámetros, valor de retorno y dirección de retorno de las subrutinas *dangling pointer* - (o *puntero colgante* en castellano) puntero que almacena una dirección - de memoria inválida. + 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 @@ -223,131 +223,131 @@ Glosario 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 @@ -355,158 +355,158 @@ Glosario (*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