From: Leandro Lucarella Date: Sun, 24 Oct 2010 03:38:48 +0000 (-0300) Subject: Correcciones de typos y errores de redacción X-Git-Tag: borrador-jurado~5 X-Git-Url: https://git.llucax.com/z.facultad/75.00/informe.git/commitdiff_plain/587f418dec03ac930616a59882c5f1a71319d692?hp=8454291bf362235221567018a6827cab9dbc7014 Correcciones de typos y errores de redacción También se agregan algunas aclaraciones con la intención de hacer el texto más claro. --- diff --git a/source/conclusion.rst b/source/conclusion.rst index 714ba5e..f702eef 100644 --- a/source/conclusion.rst +++ b/source/conclusion.rst @@ -17,11 +17,11 @@ El objetivo principal fue bajar la latencia del recolector, es decir el tiempo máximo de pausa real, y se pudo comprobar que, salvo en casos muy particulares, esto fue conseguido de manera contundente (con tiempos de pausa hasta 200 veces menores que el recolector original de D_). La inclusión del -marcado concurrente demostró ser una aproximación correcta al problema. +marcado concurrente demostró ser una forma eficaz de atacar el problema. La aceptación de la solución por parte de la comunidad también ha sido un objetivo importante de este trabajo, y si bien en este sentido sigue siendo un -trabajo en curso, la recepción ha sido ampliamente positiva por parte de la +trabajo en progreso, la recepción ha sido ampliamente positiva por parte de la comunidad y se espera que el resultado de este trabajo sea incorporado en el corto plazo tanto a `D 1.0`_ a través de Tango_, como a `D 2.0`_. @@ -49,10 +49,10 @@ existen *balas de plata*, y cada programa tiene necesidades particulares en cuanto a recolección de basura. Por lo tanto, distintos programas pueden verse beneficiados o perjudicados por diferentes configuraciones. Esto hace que la posibilidad de configurar el recolector en tiempo de inicialización sea -particularmente ventajoso. +particularmente útil. Finalmente, algunas optimizaciones muy pequeñas demostraron ser también muy -valiosas para algunos casos particulares, logrando reducciones en el tiempo +valiosas para ciertos casos particulares, logrando reducciones en el tiempo total de ejecución de hasta 5 veces. @@ -71,11 +71,12 @@ y limitaciones conocidas. A continuación se describe cada una de ellos. Entre las herramientas de depuración que provee el recolector, no se ha mencionado la posibilidad de emitir opcionalmente mensajes informativos para ayudar a depurar tanto problemas en el recolector como en el programa que lo - usa. El recolector actual tiene esa posibilidad pero es elegible en tiempo de - compilación. En este trabajo se agregaron las opciones en tiempo de - inicialización ``log_file`` y ``verbose`` con el propósito de poder elegir un - archivo en donde guardar los mensajes informativos y el nivel de detalle de - dichos mensajes respectivamente, pero finalmente nunca se implementaron. + usa. El recolector actual tiene esa posibilidad pero es configurable en + tiempo de compilación. En este trabajo se agregaron las opciones en tiempo + de inicialización ``log_file`` y ``verbose`` con el propósito de poder + elegir un archivo en donde guardar los mensajes informativos y el nivel de + detalle de dichos mensajes respectivamente, pero finalmente nunca se + implementaron. * Predicción para estimar cuando lanzar una recolección temprana. @@ -298,8 +299,8 @@ Trabajos relacionados Dado que D_ no ha penetrado en ámbitos académicos, se ha encontrado un solo trabajo de investigación relacionado. Sin embargo se ha encontrado otro -trabajo que si bien no es formal, ha sido de mucha importancia para el -desarrollo de este trabajo. +que si bien no es formal, ha sido de mucha importancia para el desarrollo de +esta tesis. A continuación se describen ambos. @@ -320,7 +321,7 @@ A continuación se describen ambos. * Integración de marcado preciso del *heap* al recolector de basura [DBZ3463]_. - Ya citado varias veces en este trabajo, fue comenzado por David Simcha + Ya citado varias veces en este trabajo; fue comenzado por David Simcha y publicado en el sistema de seguimiento de fallas de D_ que se limita a una implementación a nivel biblioteca de usuario y sobre `D 2.0`_. Vincent Lang (mejor conocido como *wm4* en la comunidad de D_) da continuidad a este diff --git a/source/dgc.rst b/source/dgc.rst index 7b54595..497e20e 100644 --- a/source/dgc.rst +++ b/source/dgc.rst @@ -5,19 +5,20 @@ Recolección de basura en D ============================================================================ D_ propone un nuevo desafío en cuanto al diseño de un recolector de basura, -debido a la gran cantidad características que tiene y paradigmas que soporta. +debido a la gran cantidad de características que tiene y paradigmas que +soporta. D_ ya cuenta con un recolector que hace lo necesario para funcionar de forma -aceptable, pero su diseño e implementación son relativamente sencillas -comparadas con el :ref:`estado del arte ` de la recolección de basura +aceptable, pero su diseño e implementación son relativamente sencillos +comparados con el :ref:`estado del arte ` de la recolección de basura en general. Además la implementación actual presenta una serie de problemas que se evidencia en las quejas que regularmente la comunidad de usuarios de D_ menciona en el grupo de noticias. En esta sección se analizarán las necesidades particulares de D_ con respecto a la recolección de basura. También se analiza el diseño e implementación del -recolector actual y finalmente se presenta una recompilación de los -principales problemas que presenta. +recolector actual, presentando sus fortalezas y debilidades. Finalmente se +analiza la viabilidad de los diferentes algoritmos vistos en :ref:`gc_art`. @@ -52,11 +53,11 @@ memoria de éste. Esta característica es muy inusual en un recolector, a excepción de recolectores conservativos diseñados para C/C++ que tienen las mismas (o más) limitaciones. -El control sobre la alineación de memoria es otra complicación sobre el -recolector de basura, incluso aunque éste sea conservativo. Dado que tratar la -memoria de forma conservativa byte a byte sería impracticable (tanto por la -cantidad de *falsos positivos* que esto provocaría como por el impacto en el -rendimiento por el exceso de posibles punteros a revisar, además de lo +La posibilidad de controlar la alineación de memoria es otra complicación +sobre el recolector de basura, incluso aunque éste sea conservativo. Dado que +tratar la memoria de forma conservativa byte a byte sería impracticable (tanto +por la cantidad de *falsos positivos* que esto provocaría como por el impacto +en el rendimiento por el exceso de posibles punteros a revisar, además de lo ineficiente que es operar sobre memoria no alineada), en general el recolector asume que el usuario nunca va a tener la única referencia a un objeto en una estructura no alineada al tamaño de palabra. @@ -134,7 +135,7 @@ La especificación dice [DWDE]_: Afortunadamente el orden de finalización no está definido, ya que esto sería extremadamente difícil de proveer por un recolector (si no imposible). Esto -significa que si bien se ejecutan el destructores de los objetos que dejan de +significa que si bien se ejecutan los destructores de los objetos que dejan de ser alcanzables desde el *root set*, no se define en que orden se hace, y por lo tanto un objeto no puede acceder a sus atributos que sean referencias a otros objetos en un destructor. @@ -147,17 +148,17 @@ los atributos que sean referencias a otros objetos creados con ``scope`` si el orden en que fueron creados (y por lo tanto en que serán destruidos) se lo permite. -Sin embargo no hay forma actualmente de saber dentro de un destructor si este +Sin embargo no hay forma actualmente de saber dentro de un destructor si éste fue llamado determinísticamente o no, por lo tanto es virtualmente imposible hacer uso de esta distinción, a menos que una clase sea declarada para ser creada solamente utilizando la palabra reservada ``scope``. -Cabe aclarar que estrictamente hablando, según la especificación de D_, el +Cabe aclarar que, estrictamente hablando y según la especificación de D_, el recolector no debe garantizar la finalización de objetos bajo ninguna circunstancia, es decir, el recolector podría no llamar a ningún destructor. -Sin embargo esto es probablemente un problema de redacción vaga y dadas las +Sin embargo esto es probablemente una vaguedad en la redacción y dadas las garantías que provee la implementación actual la comunidad de D_ cuenta con -ellas porque además son deseables (y sencillas de implementar). +ellas. @@ -168,15 +169,14 @@ Recolector de basura actual de D Como paso básico fundamental para poder mejorar el recolector de basura de D_, primero hay que entender la implementación actual, de forma de conocer sus -puntos fuertes, problemas y limitaciones, de manera tal de poder analizar -formas de mejorarlo. +puntos fuertes, problemas y limitaciones. -Como se mencionó en la sección :ref:`d_lang`, en D_ hay dos bibliotecas base -para soportar el lenguaje (*runtimes*): Phobos_ y Tango_. La primera es la +Como se mencionó en la sección :ref:`d_lang`, hay dos bibliotecas base para +soportar el lenguaje (*runtimes*): Phobos_ y Tango_. La primera es la biblioteca estándar de D_, la segunda un proyecto más abierto y dinámico que -surgió como alternativa a Phobos_ debido a que Phobos_ es muy descuidada y que -era muy difícil impulsar cambios en ella. Ahora Phobos_ tiene el agravante de -estar *congelada* en su versión 1 (solo se realizan correcciones de errores). +surgió como alternativa a Phobos_ dado que estaba muy descuidada y que era muy +difícil impulsar cambios en ella. Ahora Phobos_ tiene el agravante de estar +*congelada* en su versión 1 (solo se realizan correcciones de errores). Dado que Tango_ está mejor organizada, su desarrollo es más abierto (aceptan cambios y mejoras) y que hay una mayor disponibilidad de programas @@ -288,13 +288,13 @@ dicho objeto. | +----------+ +----------+ +----------+ +----------+ | +----------------------------------------------------------------------+ -Cada página de un *pool* puede estar asignada a contener bloques de un tamaño -específico o puede estar libre. A su vez, cada bloque puede estar ocupado por -una celda o estar libre. Los bloques libres de un tamaño específico (a -excepción de aquellos bloques que ocupen una página entera) además forman -parte de una :ref:`lista de libres ` (ver figura -:vref:`fig:dgc-free-list`). Esto permite asignar objetos relativamente -pequeños de forma bastante eficiente. +Cada página de un *pool* puede tener asignado un tamaño de bloque específico +o puede estar libre. A su vez, cada bloque puede estar ocupado por una celda +o estar libre. Los bloques libres de un tamaño específico (a excepción de +aquellos bloques que ocupen una página entera) además forman parte de una +:ref:`lista de libres ` (ver figura :vref:`fig:dgc-free-list`). +Esto permite asignar objetos relativamente pequeños de forma bastante +eficiente. .. flt:: fig:dgc-free-list @@ -349,17 +349,17 @@ 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á - 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). + Indica que la página está completamente libre y 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, - que ocupa una o más páginas). Luego se presentan más detalles sobre objetos + que ocupa dos o más páginas). Luego se presentan más detalles sobre objetos grandes. -Las páginas con esto tamaños de bloque especiales (conceptualmente) no +Las páginas con estos tamaños de bloque especiales conceptualmente no contienen bloques. @@ -381,8 +381,8 @@ Cada bloque tiene asociados varios atributos: 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*). + :ref:`algoritmo actual ` (las celdas con 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 @@ -390,7 +390,7 @@ Cada bloque tiene asociados varios atributos: *noscan* 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*). + tanto no debe ser escaneado (no tiene *hijas*). Objetos grandes @@ -443,7 +443,7 @@ básicas de cualquier algoritmo de :ref:`marcado y barrido `:: Fase de marcado ^^^^^^^^^^^^^^^ -Esta fase consiste de varios pasos, que pueden resumirse en el siguiente +Esta fase consiste de varios pasos, que pueden describirse con el siguiente algoritmo:: function mark_phase() is @@ -452,10 +452,10 @@ algoritmo:: clear_mark_scan_bits() mark_free_lists() mark_static_data() - push_registers_into_stack() + push_registers_into_stack(thread_self) thread_self.stack.end = get_stack_top() mark_stacks() - pop_registers_from_stack() + pop_registers_from_stack(thread_self) mark_user_roots() mark_heap() start_the_world() @@ -467,24 +467,30 @@ iteración se interrumpe cuando no hay más celdas por visitar. Las funciones ``stop_the_world()`` y ``start_the_world()`` pausan y reanudan todos los hilos respectivamente (salvo el actual). Al pausar los hilos además -se guardan los registros del procesador en el *stack* y se guarda la posición -actual del *stack* para que la fase de marcado pueda recorrerlos:: +se apilan los registros del procesador en el *stack* y se guarda la posición +actual del *stack* para que la fase de marcado pueda recorrerlos [#dgcstw]_:: function stop_the_world() is foreach thread in threads if thread is thread_self continue thread.pause() - push_registers_into_stack() + push_registers_into_stack(thread) thread.stack.end = get_stack_top() function start_the_world() is - foreach thread in threads + foreach thread in reversed(threads) if thread is thread_self continue - pop_registers_from_stack() + pop_registers_from_stack(thread) thread.resume() +.. [#dgcstw] El procedimiento para apilar y desapilar los registros en el + *stack* se realiza en realidad utilizando las señales ``SIGUSR1`` + y ``SIGUSR2`` (respectivamente). Es el manejador de la señal el que en + realidad apila y desapila los registros y guarda el puntero al *stack*. Se + omiten los detalles para simplificar la explicación del algoritmo. + La función ``clear_mark_scan_bits()`` se encarga de restablecer todos los atributos *mark* y *scan* de cada bloque del *heap*:: @@ -503,7 +509,7 @@ tiempo sin sentido y potencialmente manteniendo *vivas* celdas que en realidad son *basura* (*falsos positivos*):: function mark_free_lists() is - foreach free_list in heap + foreach free_list in free_lists foreach block in free_list block.mark = true block.free = true @@ -525,15 +531,16 @@ Primero se marca el área de memoria estática de manera :ref:`conservativa Para poder tomar los registros como parte del *root set* primero se apilan en el *stack* a través de la función:: - function push_registers_into_stack() is - foreach register in registers + function push_registers_into_stack(thread) is + foreach register in thread.registers push(register) -Y luego se descartan (no es necesario ni correcto restablecer los valores ya -que podrían tener nuevos valores) al sacarlos de la pila:: +Y luego, al reiniciar los hilos cuando se termina de marcar, se descartan +sacándolos de la pila (no es necesario ni correcto restablecer los valores ya +que podrían tener nuevos valores):: - function pop_registers_from_stack() is - foreach register in reverse(registers) + function pop_registers_from_stack(thread) is + foreach register in reverse(thread.registers) pop() Una vez hecho esto, basta marcar (de forma conservativa) los *stacks* de todos @@ -621,7 +628,7 @@ utilizadas en la fase de marcado:: big_object_end = find_big_object_end(pool, page) if big_object_start <= pointer < big_object_end return [pool, page, big_object_start] - else if page.bloc_size < PAGE + else if page.block_size < PAGE foreach block in page block_start = cast(byte*) block block_end = block_start + page.block_size @@ -679,14 +686,14 @@ a la función ``finalize()``. Esta función es un servicio que provee la biblioteca *runtime* y en última instancia llama al destructor del objeto almacenado en el bloque a liberar. -Una vez marcados todos los bloques y páginas como libre, se procede -a reconstruir las listas de libres. En el proceso buscan las páginas que -tengan todos los bloques libres para marcar la página completa como libre (de -manera que pueda utilizarse para albergar otro tamaño de bloque u objetos -grandes de ser necesario):: +Una vez marcados todos los bloques y páginas con ``free``, se procede +a reconstruir las listas de libres. Como parte de este proceso se buscan las +páginas que tengan todos los bloques libres para marcar la página completa +como libre (de manera que pueda utilizarse para albergar otro tamaño de bloque +u objetos grandes de ser necesario):: function rebuild_free_lists() is - foreach free_list in heap + foreach free_list in free_lists free_list.clear() foreach pool in heap foreach page in pool @@ -776,9 +783,10 @@ Para intentar buscar un bloque de memoria libre se realiza lo siguiente:: block = free_lists[block_size].pop_first() return block -Si no se puede obtener un bloque de la lista de libres correspondiente, se -busca asignar una página libre al tamaño de bloque deseado de forma de -*alimentar* la lista de libres con dicho tamaño:: +Donde ``pop_first()`` retorna ``null`` si la lista estaba vacía. Si no se +puede obtener un bloque de la lista de libres correspondiente, se busca +asignar una página libre al tamaño de bloque deseado de forma de *alimentar* +la lista de libres con dicho tamaño:: function assign_page(block_size) is foreach pool in heap @@ -816,7 +824,7 @@ todo falla, la función ``new()`` termina lanzando una excepción indicando que se agotó la memoria. Si el tamaño de bloque necesario para cumplir con la asignación de memoria es -de una página, entonces se utiliza otro algoritmo para alocar un objeto +de una o más páginas, entonces se utiliza otro algoritmo para alocar un objeto grande:: function new_big(size) is @@ -943,10 +951,10 @@ Detalles de implementación ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Hay varias diferencias a nivel de implementación entre lo que se presentó en -las secciones anteriores y como está implementado realmente el recolector -actual. Con los conceptos e ideas principales del ya explicadas, se procede -a ahondar con más detalle en como está construido el recolector y algunas de -sus optimizaciones principales. +las secciones anteriores y como está escrito realmente el recolector actual. +Con los conceptos e ideas principales ya explicadas, se procede a ahondar con +más detalle en como está construido el recolector y algunas de sus +optimizaciones principales. Vale aclarar que el recolector de basura actual está implementado en D_. @@ -978,7 +986,7 @@ Estado interno del recolector `). Es análoga a la variable ``more_to_scan`` presentada en :ref:`dgc_algo_mark`. - *inited* + *inited* (sic) Indica si el recolector fue inicializado. *stackBottom* @@ -1017,11 +1025,11 @@ Atributos que cambian el comportamiento Optimizaciones *p_cache*, *size_cache* - 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é*. + Caché del tamaño de bloque para un puntero dado. Obtener el tamaño de un + bloque 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 en un caché (de un solo + elemento) el último valor calculado. *minAddr*, *maxAddr* Punteros al principio y fin del *heap*. Pueden haber *huecos* entre @@ -1044,7 +1052,8 @@ destacar que para implementar el recolector no se pueden utilizar los arreglos dinámicos de D_ (ver sección :ref:`d_high_level`) dado que éstos utilizan de forma implícita el recolector de basura, por lo tanto todos los arreglos variables del recolector se implementan utilizando las funciones de -C ``malloc()``, ``realloc()`` y ``free()`` directamente. +C :manpage:`malloc(3)`, :manpage:`realloc(3)` y :manpage:`free(3)` +directamente. La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura @@ -1078,7 +1087,7 @@ La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura secciones anteriores para mayor claridad). *mark*, *scan*, *freebits*, *finals*, *noscan* - Conjunto de bits (*bitsets*) para almacenar los indicadores descriptos en + Conjuntos 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. @@ -1104,7 +1113,7 @@ La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura Como se observa, además de la información particular del *pool* se almacena toda la información de páginas y bloques enteramente en el *pool* también. -Esto simplifica el manejo de que lo es memoria *pura* del *heap*, ya que queda +Esto simplifica el manejo de lo que es memoria *pura* del *heap*, ya que queda una gran porción continua de memoria sin estar intercalada con meta-información del recolector. @@ -1125,7 +1134,7 @@ no predomina un tamaño de bloque pequeño. Listas de libres ^^^^^^^^^^^^^^^^ Las listas de libres se almacenan en el recolector como un arreglo de -estructuras ``Lista``, que se compone solamente de un atributo ``List* next`` +estructuras ``List``, que se compone solamente de un atributo ``List* next`` (es decir, un puntero al siguiente). Entonces cada elemento de ese arreglo es un puntero al primer elemento de la lista en particular. @@ -1140,7 +1149,7 @@ Algoritmos ^^^^^^^^^^ Los algoritmos en la implementación real son considerablemente menos modulares que los presentados en la sección :ref:`dgc_algo`. Por ejemplo, la función -``collect()`` es una gran función de 300 líneas de código. +``collect()`` es una gran función de 300 líneas de código fuente. A continuación se resumen las funciones principales, separadas en categorías para facilitar la comprensión. Los siguientes son métodos de la estructura @@ -1164,7 +1173,7 @@ Manipulación de raíces definidas por el usuario Agrega, remueve e itera sobre los rangos de raíces definidas por el usuario. -Manipulación de indicadores +Manipulación de bits indicadores *getBits(pool, biti)* Obtiene los indicadores especificados para el bloque de índice ``biti`` en el *pool* ``pool``. @@ -1294,12 +1303,11 @@ Recolección presentado en la sección :ref:`dgc_algo_mark`. *fullcollectshell()* - 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 - función ``collect()`` o en una función que luego la llame (como en este - caso). + Guarda los registros del procesador asignado al hilo actual en su + *stack* y llama a ``fullcollect()``. El resto de los hilos son pausados + y sus registros apilados por la función del *runtime* + ``thread_suspendAll()`` (y restablecidos y reiniciados por + ``thread_resumeAll()``. *fullcollect(stackTop)* Realiza la recolección de basura. Es análoga a ``collect()`` pero es @@ -1330,10 +1338,10 @@ Memoria *encomendada* El algoritmo actual divide un *pool* en dos áreas: memoria *encomendada* (*committed* en inglés) y *no-encomendada*. Esto se debe a que originalmente el compilador de D_ DMD_ solo funcionaba en Microsoft Windows y este sistema -operativo puede asignar memoria en dos niveles. Por un lado puede asignar al -proceso un espacio de memoria (*address space*) pero sin asignarle la memoria -correspondiente. En un paso posterior se puede *encomendar* la memoria (es -decir, asignar realmente la memoria). +operativo puede asignar memoria en dos niveles. En principio se puede asignar +al proceso un espacio de memoria (*address space*) pero sin asignarle la +memoria virtual correspondiente. En un paso posterior se puede *encomendar* la +memoria (es decir, asignar realmente la memoria virtual). Para aprovechar esta característica el recolector diferencia estos dos niveles. Sin embargo, esta diferenciación introduce una gran complejidad (que @@ -1342,9 +1350,10 @@ y convierte lo que es una ventaja en un sistema operativo en una desventaja para todos los demás (ya que los cálculos extra se realizan pero sin ningún sentido). De hecho hay sistemas operativos, como Linux_, que realizan este trabajo automáticamente (la memoria no es asignada realmente al programa hasta -que el programa no haga uso de ella; esta capacidad se denomina *overcommit*). +que el programa no haga uso de ella; a esta capacidad se la denomina +*overcommit*). -Como se vio en la figura :vref:`fig:dgc-pool`, lás páginas de un *pool* se +Como se vio en la figura :vref:`fig:dgc-pool`, las páginas de un *pool* se dividen en *committed* y *uncommitted*. Siempre que el recolector recorre un *pool* en busca de una página o bloque, lo hace hasta la memoria *committed*, porque la *uncommitted* es como si jamás se hubiera pedido al sistema @@ -1360,7 +1369,7 @@ soporta múltiples *mutator*\ s. La forma de implementarlo es la más simple. Todas las operaciones sobre el recolector que se llaman externamente están sincronizadas utilizando un *lock* global (excepto cuando hay un solo hilo *mutator*, en cuyo caso se omite la sincronización). Esto afecta también a la -asignación de memoria. +asignación de memoria y cualquier otro servicio provisto por el recolector. @@ -1408,9 +1417,9 @@ podrían aplicarse a D_ y otras que no (como *pointer reversal*) [JOLI96]_. El recolector actual, sin embargo, cambia complejidad en espacio por complejidad en tiempo, utilizando un algoritmo iterativo que es constante (:math:`O(1)`) en espacio, pero que requiere varias pasada sobre el *heap* en vez de una (la -cantidad de pasadas es en el peor caso, al igual que la cantidad de -recursiones del algoritmo recursivo, :math:`O(|Live \thickspace set|)`, pero -cada pasada se realiza por sobre todo el *heap*). +cantidad de pasadas en el peor caso es :math:`O(|Live \thickspace set|)`, al +igual que la profundidad del algoritmo recursivo, pero cada pasada se realiza +sobre todo el *heap*). Conjuntos de bits para indicadores @@ -1463,14 +1472,15 @@ Las opciones más importantes son: ``SENTINEL`` Su función detectar errores producidos por escribir más allá (o antes) del - área de memoria solicitada y está implementado reservando un poco más de - memoria de la que pide el usuario, devolviendo un puntero a un bloque - ubicado dentro del bloque real reservado (en vez de al inicio) y finalmente - escribiendo un patrón de bits en los extremos del borde real (ver figura - :vref:`fig:sentinel`), de forma de poder verificar en distintas situación - (por ejemplo al barrer el bloque) que esas áreas de más con los patrones de - bits estén intactas. Esto permite detectar de forma temprana errores tanto - en el recolector como en el programa del usuario. + área de memoria solicitada. Está implementado reservando un poco más de + memoria de la que pide el usuario y devolviendo un puntero a un bloque + ubicado dentro del bloque real reservado (en vez de al inicio). Escribiendo + un patrón de bits en los extremos del bloque real (ver figura + :vref:`fig:sentinel`) se puede verificar, en distintas situaciones (como + por ejemplo al barrer el bloque), que esas guardas con los patrones de bits + estén intactas (en caso contrario se ha escrito por fuera de los límites + del bloque solicitado). Esto permite detectar de forma temprana errores + tanto en el recolector como en el programa del usuario. .. flt:: fig:sentinel @@ -1621,8 +1631,8 @@ Se recuerda que la semántica de dicha función es la misma que la de la funció Además, como se comentó en la sección anterior, los algoritmos en la implementación real son considerablemente menos modulares que los presentados -en la sección :ref:`dgc_algo`. Por ejemplo, la función ``fullcollect()`` son -300 líneas de código. +en la sección :ref:`dgc_algo`. Por ejemplo, la función ``fullcollect()`` tiene +300 líneas de código fuente. Memoria *encomendada* @@ -1632,8 +1642,8 @@ Como se comentó en la sección anterior, diferenciar entre memoria particular para sistemas operativos que no hacen esta distinción, al menos explícitamente, donde no hay ningún beneficio en realizar esta distinción). -Incluso para Microsoft Windows, la ventaja de realizar esta distinción es -discutible. +Incluso para Microsoft Windows, la ventaja de realizar esta distinción debería +ser comprobada. Precisión @@ -1649,7 +1659,7 @@ De todas maneras queda mucho lugar para mejoras, y es un tema recurrente en el grupo de noticias de D_ y se han discutido formas de poder hacer que, al menos el *heap* sea preciso [NGD44607]_ [NGD29291]_. Además se mostró un interés general por tener un recolector más preciso [NGD87831]_, pero no han habido -avances al respecto. +avances al respecto hasta hace muy poco tiempo. Otra forma de minimizar los efectos de la falta de precisión que se ha sugerido reiteradamente en el grupo es teniendo la @@ -1660,19 +1670,22 @@ y en particular para mejorar la implementación de de arreglos asociativos. Referencias débiles ^^^^^^^^^^^^^^^^^^^ -El recolector actual no dispone de soporte de *referencias débiles* -[#dgcweakref]_, sin embargo hay una demanda apreciable [NGD86840]_ [NGD13301]_ -[NGL8264]_ [NGD69761]_ [NGD74624]_ [NGD88065]_. +Si bien el recolector de Tango_ tiene un soporte limitado de *referencias +débiles* [#dgcweakref]_, el de Phobos_ no dispone de ningún soporte (por lo +tanto no está contemplado oficialmente el lenguaje). Sin embargo hay una +demanda apreciable [NGD86840]_ [NGD13301]_ [NGL8264]_ [NGD69761]_ [NGD74624]_ +[NGD88065]_. .. [#dgcweakref] Una referencia débil (o *weak reference* en inglés) es aquella que que no protege al objeto referenciado de ser reciclado por el recolector. Para cubrir esta demanda, se han implementado soluciones como biblioteca para -suplir la inexistencia de una implementación oficial [NGA9103]_. +suplir la inexistencia de una implementación oficial [NGA9103]_ (la +implementación de Tango_ es otro ejemplo). -Sin embargo éstas son en general poco robustas, extremadamente dependientes -de la implementación del recolector y, en general, presentan problemas muy +Sin embargo éstas son en general poco robustas, extremadamente dependientes de +la implementación del recolector y, en general, presentan problemas muy sutiles [NGD88065]_. Por esta razón se ha discutido la posibilidad de incluir la implementación de *referencias débiles* como parte del lenguaje [NGD88559]_. @@ -1689,7 +1702,7 @@ de hilos, de manera de disminuir la contención, al menos para la asignación de memoria [NGD75952]_ [NGD87831]_. Además se ha mostrado un interés por tener un nivel de concurrencia aún mayor -en el recolector, para aumentar la concurrencia en ambientes *multi-core* en +en el recolector, para aumentar la eficiencia en ambientes *multi-core* en general pero en particular para evitar grandes pausas en programas con requerimientos de tiempo real, históricamente una de las principales críticas al lenguaje [NGD87831]_ [NGL3937]_ [NGD22968]_ [NGA15246]_ [NGD5622]_ @@ -1708,10 +1721,9 @@ cuyo caso la omisión de la finalización queda por completo fuera del control del usuario (y lo que es aún peor, el usuario no puede ser siquiera notificado de esta anomalía). -Si bien la especificación de D_ no requiere esta capacidad (de hecho, -rigurosamente hablando la especificación de D_ no garantiza la finalización de -objetos bajo ninguna circunstancia), no hay mayores problemas para implementar -un recolector que de este tipo de garantías [NGD88298]_. +Si bien la especificación de D_ no requiere esta capacidad, no hay mayores +problemas para implementar un recolector que dé este tipo de garantías +[NGD88298]_. Además los objetos pueden ser finalizados tanto determinísticamente (utilizando ``delete`` o ``scope``; ver secciones :ref:`d_low_level` @@ -1751,8 +1763,8 @@ lenguaje. Dado que es imposible que un recolector sea óptimo para todo tipo de programas, es muy deseable permitir una configuración de parámetros del -recolector que permitan al usuario ajustarlo a las necesidades particulares de -sus programas. +recolector que permitan al usuario ajustarlos a las necesidades particulares +de sus aplicaciones. .. _dgc_bad_ocup: @@ -1856,9 +1868,8 @@ recolectar ciclos. Sin embargo hay otras razones importantes. Una de ellas es la inter-operatividad con C. El utilizar un contador de referencias requiere la manipulación del contador por parte del código C con el que se interactúe. Si bien este problema ya está presente si código -C guarda un puntero a un objeto almacenado en el *heap* del recolector de D_ -en el *heap* de C (es decir, en una celda de memoria asignada por -``malloc()``), esto es poco común. Sin embargo, mientras que una función de +C guarda en su *headp* un puntero a un objeto almacenado en el *heap* del +recolector de D_, esto es poco común. Sin embargo, mientras que una función de C se está ejecutando, es extremadamente común que pueda almacenar en el *stack* una referencia a un objeto de D_ y en ese caso el recolector actual puede manejarlo (mientras la función de C esté corriendo en un hilo creado por @@ -1920,10 +1931,10 @@ conservando la base del algoritmo, es posible realizar una cantidad de mejoras considerable. Una de las principales mejoras que pueden realizarse es hacer al recolector -:ref:`concurrente ` y parcialmente más :ref:`preciso -`. Estas dos mejoras solamente alcanzarían para mejorar de forma -notable el tiempo de pausa en las recolecciones y la cantidad de memoria -retenida debido a *falsos positivos*. +:ref:`concurrente ` y más :ref:`preciso `. Estas +dos mejoras solamente alcanzarían para mejorar de forma notable el tiempo de +pausa en las recolecciones y la cantidad de memoria retenida debido a *falsos +positivos*. Más adelante veremos detalles sobre algunos de estos aspectos y sobre algunos algoritmos particulares que permiten hacer concurrente al recolector actual. @@ -1996,11 +2007,9 @@ Recolección concurrente / paralela / *stop-the-world* El recolector actual es *stop-the-world*, sin embargo esta es una de las principales críticas que tiene. El recolector se podría ver beneficiado de recolección paralela, tanto para realizar la recolección más velozmente en -ambientes *multi-core*, como para disminuir el tiempo de pausa. Sin embargo, -el hecho de que todos los hilos se pausen para realizar parte del trabajo del -recolector puede ser contraproducente para programas *real-time* que pretendan -usar un hilo que no sufra de la latencia del recolector, asegurando que nunca -lo use (aunque se podrían ver esquemas para ajustarse a estas necesidades). +ambientes *multi-core*, como para disminuir el tiempo de pausa, un factor muy +importante para programas que necesiten tener baja latencia, como programas +*real-time*. En general los recolectores concurrentes necesitan también instrumentar el *mutator* para reportar cambios en el grafo de conectividad al recolector, @@ -2046,12 +2055,12 @@ siguientes razones: determinado momento. Sin embargo el costo de pedir al usuario este tipo de restricción puede ser muy alto. -Sin embargo, ya hay un trabajo relacionado avanzando en este sentido, que -agrega precisión al marcado del *heap*. David Simcha comienza con este trabajo -explorando la posibilidad de agregar precisión parcial al recolector, -generando información sobre la ubicación de los punteros para cada tipo -[DBZ3463]_. Su trabajo se limita a una implementación a nivel biblioteca de -usuario y sobre `D 2.0`_. Desafortunadamente su trabajo pasa desapercibido +Durante el desarrollo de este trabajo se encontra un trabajo relacionado +avanzando en este sentido, que agrega precisión al marcado del *heap*. David +Simcha comienza explorando la posibilidad de agregar precisión parcial al +recolector, generando información sobre la ubicación de los punteros para cada +tipo [DBZ3463]_. Su trabajo se limita a una implementación a nivel biblioteca +de usuario y sobre `D 2.0`_. Desafortunadamente su trabajo pasa desapercibido por un buen tiempo. Sin embargo un tiempo después Vincent Lang (mejor conocido como *wm4* en la @@ -2104,8 +2113,7 @@ garantizado que no existan conexiones entre celdas de las distintas particiones, requiere grandes cambios en el compilador y realizar análisis estático bastante complejo [HIRZ03]_. Además al ser D_ un lenguaje de bajo nivel, es muy difícil garantizar que estas conexiones inter-particiones no -puedan existir realmente; y de poder lograrlo, podría ser demasiado -restrictivo. +puedan existir realmente; y de hacerlo, podría ser demasiado restrictivo. .. include:: links.rst diff --git a/source/gc.rst b/source/gc.rst index f4acb4b..ae398cf 100644 --- a/source/gc.rst +++ b/source/gc.rst @@ -2327,17 +2327,17 @@ y barrido ` no lo hacen. Además hay otro algoritmo bastante básico que mueve celdas, el **marcado y compactado**. Éste no tiene 2 semi-espacios, directamente mueve las celdas compactándolas al comienzo del *heap*. El algoritmo es un poco más complejo que la :ref:`copia de -semi-espacios ` pero suele poder proveer una mayor localidad de -referencia y *desperdicia* un semi-espacio que está inutilizado salgo en el -momento de la recolección. Por ejemplo para Mono_, que antes usaba un -recolector conservativo sin movimiento ([BOEHWD]_) se está implementando un -recolector de este tipo [MOLAWE]_ [MOLA06]_. +semi-espacios ` pero suele proveer una mayor localidad de referencia +y no *desperdicia* un semi-espacio que está inutilizado salvo en el momento de +la recolección. Por ejemplo para Mono_, que antes usaba un recolector +conservativo sin movimiento ([BOEHWD]_) se está implementando un recolector de +este tipo [MOLAWE]_ [MOLA06]_. .. _gc_conserv: -Recolectores conservativos vs precisos +Recolectores conservativos versus precisos ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Los recolectores *conservativos* son aquellos que tienen la capacidad de poder @@ -2348,8 +2348,8 @@ o no. Esto trae una variada cantidad de problemas, como retención de celdas que en realidad son *basura* simplemente porque hay algún dato que coincide con la dirección de memoria en la que está almacenada esa celda *basura* [#gcflasepos]_. Además los recolectores puramente conservativos no puede mover -celdas (ver :ref:`gc_moving`), porque no pueden arriesgarse a actualizar los -punteros por el riesgo que existe de que sean *falsos positivos*. +celdas (ver :ref:`gc_moving`), dado que no pueden actualizar los supuestos +punteros por la posibilidad de que sean *falsos positivos*. .. [#gcflasepos] Esto es lo que se conoce como un *falso positivo*, algo que aparenta ser un puntero pero en realidad no lo es. @@ -2446,7 +2446,7 @@ completo). Sin embargo, a pesar de ser este el esquema más difundido para dividir el *heap* y realizar una recolección parcial sobre un área de alta concentración -de basura no es la única. Otros recolectores proponen hacer un análisis +de basura, no es la única. Otros recolectores proponen hacer un análisis estático del código revisando la conectividad entre los objetos según sus tipos (esto es posible solo en lenguajes con *tipado* estático), de manera tal de separar en distintas áreas grupos de tipos que no pueden tener referencias diff --git a/source/glosario.rst b/source/glosario.rst index 8133ba5..da238ad 100644 --- a/source/glosario.rst +++ b/source/glosario.rst @@ -106,7 +106,7 @@ Glosario *stack* Área de memoria organizada en forma de pila donde se almacenan típicamente las variables locales, parámetros, valor de retorno - y dirección de retorno de las subrutinas + y dirección de retorno de las subrutinas. *dangling pointer* Puntero que almacena una dirección de memoria inválida (*puntero @@ -254,7 +254,7 @@ Glosario los mismo parámetros siempre devuelve el mismo resultado. *runtime* - Biblioteca base de un lenguaje que provee los servicios básicos (como + Biblioteca de un lenguaje que provee los servicios básicos (como creación de objetos, manejo de hilos u otras construcciones que ofrezca el lenguaje). @@ -515,7 +515,7 @@ Glosario CSV Formato simple para almacenar datos en forma de tabla, separados por - comas (de ahí el nombre, en inglés *Comma separated values**) en un + comas (de ahí el nombre, en inglés *Comma separated values*) en un archivo de texto. Cada línea del archivo es interpretada como una fila de datos relacionados, y cada valor de separado por comas como una columna. diff --git a/source/solucion.rst b/source/solucion.rst index 7cf64b7..71703ff 100644 --- a/source/solucion.rst +++ b/source/solucion.rst @@ -58,10 +58,10 @@ noticias de D_ [#benchmod]_) programas triviales sintetizados con el único propósito de mostrar problemas con el recolector de basura. Otros programas de este estilo fueron escritos explícitamente para este trabajo. -Además se han recolectado [#benchmod]_ algunos pequeños programas portados de -otros lenguajes de programación, que si bien son pequeños y tienen como -objetivo ejercitar el recolector de basura, son programas reales que resuelven -un problema concreto, lo que otorga un juego de pruebas un poco más amplio que +Además se han recolectado algunos pequeños programas portados de otros +lenguajes de programación, que si bien son pequeños y tienen como objetivo +ejercitar el recolector de basura, son programas reales que resuelven un +problema concreto, lo que otorga un juego de pruebas un poco más amplio que los programas triviales. .. [#benchmod] Cabe destacar que en general todos los programas recolectados @@ -101,9 +101,9 @@ originalmente fue concebido para mostrar un problema con la concatenación de arreglos (como se aprecia en la sentencia ``version(loseMemory)``), ejercita los aspectos más utilizados del del recolector: manipulación de arreglos y petición e memoria. Es una de las pruebas que más estresa al recolector ya -que todo el trabajo que realiza el programa es utilizar servicios de éste. +que todo el trabajo que realiza el programa es utilizar sus servicios. -El código fuente del programa es el siguiente:: +Código fuente:: const IT = 300; const N1 = 20_000; @@ -128,7 +128,6 @@ El código fuente del programa es el siguiente:: int main(char[][] args) { - Population testPop1 = new Population; Population testPop2 = new Population; Individual[N2] indi; @@ -162,8 +161,8 @@ El objetivo de estos programas es medir el impacto de las pausas del recolector. Se espera medir dos tipos de pausa principales, por un lado el tiempo máximo de pausa real, que puede involucrar a más de un hilo y por otro el tiempo de *stop-the-world*, es decir, el tiempo en que los hilos son -efectivamente pausados por el recolector para tomar una *foto* de la pila -y registros para agregarlos al *root set*. +efectivamente pausados por el recolector para realizar una tarea que necesite +trabajar con una versión estática de la memoria del programa. Se espera ``concpu`` sea capaz de explotar cualquier reducción en el tiempo de *stop-the-world*, ya que los hilos solo son interrumpidos por este tipo de @@ -172,7 +171,7 @@ máximo de pausa, que podrían sufrir los hilos incluso cuando el *mundo* sigue su marcha, debido al *lock* global del recolector y que los hilos usan servicios de éste. -El código de ``concpu`` es el siguiente:: +Código fuente de ``concpu``:: import tango.core.Thread: Thread; import tango.core.Atomic: Atomic; @@ -267,8 +266,8 @@ servicios del recolector, por lo tanto un programa multi-hilo en el cual los hilos (aparentemente) no comparten ningún estado, se puede ver considerablemente afectado por el recolector (siendo este efecto más visible en ambientes *multi-core* por el nivel de sincronización extra que significa -a nivel de *hardware*). Cabe destacar que, sin embargo, en Linux_ no es tan -notorio. +a nivel de *hardware*). Cabe destacar, sin embargo, que en Linux_ el efecto no +es tan notorio comparado al reporte de David Schima. ``split`` @@ -280,7 +279,7 @@ mostrar lo ineficiente que puede ser concatenar datos a un mismo arreglo repetidas veces y ha desembocado en una pequeña optimización que sirvió para paliar el problema de forma razonablemente efectiva [PAN09]_. -El código es el siguiente:: +Código fuente:: import tango.io.device.File: File; import tango.text.Util: delimit; @@ -312,7 +311,7 @@ accesibles desde el *root set* del grafo de conectividad. __ http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=46407 -El código del programa es el siguiente:: +Código fuente:: import tango.math.random.Random; @@ -359,7 +358,7 @@ y fue hallada__ en el grupo de noticias. __ http://shootout.alioth.debian.org/ __ http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=43991 -El código fuente es el siguiente:: +Código fuente:: import tango.util.Convert; alias char[] string; @@ -426,9 +425,9 @@ distribuida. Son programas relativamente pequeños (entre 400 y 1000 líneas de código fuente cada uno) que realizan una tarea secuencial que asigna estructuras de datos dinámicamente. Las estructuras están usualmente organizadas como listas o árboles, y muy raramente como arreglos. Los -programas pasan la mayor parte del tiempo alocando datos y el resto usando los -datos alocados, por lo que en general están acotados en tiempo por el uso de -memoria (y no de procesador). +programas pasan la mayor parte del tiempo solicitando memoria para almacenar +datos y el resto usando los datos almacenados, por lo que en general están +acotados en tiempo por el uso de memoria (y no de procesador). __ http://www.irisa.fr/caps/people/truong/M2COct99/Benchmarks/Olden/Welcome.html __ http://www.martincarlisle.com/olden.html @@ -441,7 +440,7 @@ propósito, como DaCapo__ [BLA06]_, sin embargo, dada la falta de programas disponibles en general, y de un conjunto de pruebas especialmente diseñado para evaluar el recolector de basura en D_, se decide utilizarlas en este trabajo de todos modos. Sin embargo sus resultados deben ser interpretados con -una pizca de sal por lo mencionado anteriormente. +una pizca de suspicacia por lo mencionado anteriormente. __ http://www-ali.cs.umass.edu/DaCapo/benchmarks.html __ http://www.dacapobench.org/ @@ -522,8 +521,8 @@ GPL_) es, lamentablemente, el único programa real hallado que, a pesar de estar incompleto, es lo suficientemente grande, mantenido y estable como para ser incluido en el banco de pruebas. Se trata de un compilador de D_ escrito en D_ y está incompleto porque no puede generar código (falta implementar el -análisis semántico y la generación de código), por lo que es principalmente -utilizado para generar documentación a partir del código. +análisis semántico y la generación de código). Es principalmente utilizado +para generar documentación a partir del código. El programa está compuesto por: @@ -542,10 +541,10 @@ objetos extremadamente pequeños y de tamaños poco convencionales (no múltiplo de palabras, por ejemplo). A su vez, el texto interpretado es convertido a una representación interna en forma de árbol (o *árbol de sintaxis abstracta*) modelado por tipos *livianos* y polimórficos que están organizados en arreglos -dinámicos contiguos y asociativos (que usan muchos servicios del recolector), -y que finalmente son manipulados para obtener y generar la información -necesaria, creando y dejando *morir* objetos constantemente (pero no como única -forma de procesamiento, como otras pruebas sintetizadas). +dinámicos contiguos y asociativos (que usan muchos servicios del recolector). +Finalmente estos objetos son manipulados para obtener y generar la información +necesaria, creando y dejando de usar objetos constantemente (pero no como +única forma de procesamiento, como otras pruebas sintetizadas). Por último, a diferencia de muchos otros programas escritos en D_, que dadas algunas de las ineficiencias del recolector invierten mucho trabajo en limitar @@ -621,11 +620,11 @@ tedioso y complejo, además ineficiente, por lo tanto esta opción también se descarta. Finalmente, lo que parece ser más apropiado para un recolector, es permitir la -configuración en tiempo de inicialización. Es decir, configurar el recolectar -sin necesidad de recompilar ni el programa del usuario ni el recolector, pero -antes de que el programa del usuario inicie, de manera que una vez iniciado el -recolector con ciertos parámetros, éstos no cambien nunca más en durante la -vida del programa. +configuración en *tiempo de inicialización*. Es decir, configurar el +recolectar sin necesidad de recompilar ni el programa del usuario ni el +recolector, pero antes de que el programa del usuario inicie, de manera que +una vez iniciado el recolector con ciertos parámetros, éstos no cambien nunca +más en durante la vida del programa. Este esquema provee la mejor relación entre configurabilidad, conveniencia, eficiencia y simplicidad. Una posibilidad para lograr esto es utilizar @@ -664,7 +663,7 @@ interpretado de la siguiente manera (en formato similar a :term:`BNF`): name: `namec` `namec`* value: `valuec`* namec: `valuec` - '=' - valuec: [0x01-0xFF] - ':' + valuec: [0x01-0xFF] - ':' Es decir, se compone de una lista de opciones separadas por **:**. Cada opción se especifica con un nombre, opcionalmente seguido por un valor (separados por @@ -698,53 +697,53 @@ el formato del valor de la opción de tener uno especial): número, se crea un *pool* con ese tamaño en MiB. Si, en cambio, se especifica una cadena del tipo ``3x1``, el primer número indica la cantidad de *pools* y el segundo el tamaño en MiB de cada uno (3 *pools* de 1MiB en - este caso). Ver :ref:`sol_pre_alloc` para más detalles sobre la utilidad de - esta opción. + este caso). Ver :ref:`sol_pre_alloc` más adelante para más detalles sobre + la utilidad de esta opción. ``min_free`` - El valor de esta opción indica el porcentaje mínimo porcentaje del *heap* - que debe quedar libre luego de una recolección. Siendo un porcentaje, solo - se aceptan valores entre 0 y 100, siendo su valor por omisión 5. Ver - :ref:`sol_ocup` para más detalles sobre su propósito. + El valor de esta opción indica el porcentaje mínimo del *heap* que debe + quedar libre luego de una recolección. Siendo un porcentaje, solo se + aceptan valores entre 0 y 100, siendo su valor por omisión 5. Ver + :ref:`sol_ocup` más adelante para más detalles sobre su propósito. ``malloc_stats_file`` Esta opción sirve para especificar un archivo en el cual escribir un reporte de todas la operaciones de pedido de memoria realizadas por el - programa (durante su tiempo de vida). Ver :ref:`sol_stats` para más - detalles sobre la información provista y el formato del reporte. + programa (durante su tiempo de vida). Ver :ref:`sol_stats` más adelante + para más detalles sobre la información provista y el formato del reporte. ``collect_stats_file`` Esta opción sirve para especificar un archivo en el cual escribir un reporte de todas las recolecciones hechas durante el tiempo de vida del - programa. Ver :ref:`sol_stats` para más detalles sobre la información - provista y el formato del reporte. + programa. Ver :ref:`sol_stats` más adelante para más detalles sobre la + información provista y el formato del reporte. ``conservative`` Esta opción booleana permite desactivar el escaneo preciso del *heap*, forzando al recolector a ser completamente conservativo (excepto por los bloques con el atributo ``NO_SCAN`` que siguen sin ser escaneados). Ver - :ref:`sol_precise` para más detalles sobre la existencia de esta opción. + :ref:`sol_precise` más adelante para más detalles sobre la existencia de esta opción. ``fork`` Esta opción booleana (activada por omisión) permite seleccionar si el recolector debe correr la fase de marcado en paralelo o no (es decir, si el recolector corre de forma concurrente con el *mutator*). Para más detalles - ver :ref:`sol_fork`. + ver :ref:`sol_fork` más adelante. ``eager_alloc`` Esta opción booleana (activada por omisión), sólo puede estar activa si - ``fork`` también está activa y sirve para indicar al recolector que reserve - un nuevo *pool* de memoria cuando una petición no puede ser satisfecha, - justo antes de lanzar la recolección concurrente. Ver - :ref:`sol_eager_alloc` para más detalles sobre el propósito de esta opción. + ``fork`` también lo está y sirve para indicar al recolector que reserve un + nuevo *pool* de memoria cuando una petición no puede ser satisfecha, justo + antes de lanzar la recolección concurrente. Ver :ref:`sol_eager_alloc` más + adelante para más detalles sobre el propósito de esta opción. ``early_collect`` Esta opción booleana (desactivada por omisión), también sólo puede estar activa si ``fork`` está activa y sirve para indicar al recolector que lance una recolección (concurrente) antes de que la memoria libre se termine (la recolección temprana será disparada cuando el porcentaje de memoria libre - sea menor a ``min_free``). Ver :ref:`sol_early_collect` para más detalles - sobre el propósito de esta opción. + sea menor a ``min_free``). Ver :ref:`sol_early_collect` más adelante para + más detalles sobre el propósito de esta opción. Cualquier opción o valor no reconocido es ignorado por el recolector. Se utilizan los valores por omisión de las opciones que no fueron especificadas, @@ -756,7 +755,7 @@ shell*): .. code-block:: none - D_GC_OPTS=conservative:eager_alloc=0:early_collect=1:pre_alloc=2x5 ./programa + D_GC_OPTS=conservative:eager_alloc=0:early_collect=1:pre_alloc=2x5 ./prog En este ejemplo, se activan las opciones ``conservative`` y ``early_collect``, se desactiva ``eager_alloc`` y se crean 2 *pools* de 5MiB cada uno al @@ -848,14 +847,13 @@ Mejora del factor de ocupación del *heap* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ El factor de ocupación del *heap* debe ser apropiado por dos razones. Por un lado, si el *heap* está demasiado ocupado todo el tiempo, serán necesarias -muchas recolecciones que, aunque pequeñas dado que la memoria utilizada es -poca, puede llegar a ser extremadamente ineficiente en casos patológicos (ver -:ref:`dgc_bad_ocup`). Por otro lado, si el tamaño del *heap* es extremadamente -grande (en comparación con el tamaño real del grupo de trabajo del programa), -se harán pocas recolecciones pero cada una es muy costosa, porque el algoritmo -de marcado y barrido es :math:`O(\lvert Heap \rvert)` (ver -:ref:`gc_mark_sweep`). Además la afinidad del caché va a ser extremadamente -pobre. +muchas recolecciones, lo que puede llegar a ser extremadamente ineficiente en +casos patológicos (ver :ref:`dgc_bad_ocup`). Por otro lado, si el tamaño del +*heap* es extremadamente grande (en comparación con el tamaño real del grupo +de trabajo del programa), se harán pocas recolecciones pero cada una es muy +costosa, porque el algoritmo de marcado y barrido es :math:`O(\lvert Heap +\rvert)` (ver :ref:`gc_mark_sweep`). Además la afinidad del caché va a ser +extremadamente pobre. Para mantener el factor de ocupación dentro de límites razonables, se agrega la opción ``min_free`` (ver :ref:`sol_config_spec`). Esta opción indica el @@ -882,8 +880,9 @@ complejidad agregada. Probablemente el caso más significativo, y por tanto el único que vale la pena mencionar, es la conversión de marcado iterativo a marcado recursivo y luego a un esquema híbrido. Como se describe en :ref:`dgc_bad`, el marcado iterativo -tiene sus ventajas, pero tiene desventajas también. Al convertirlo a puramente -recursivo, es impracticable por resultar en errores de desbordamiento de pila. +tiene sus ventajas, pero tiene desventajas también. La conversión a puramente +recursivo resulta impracticable dado que desemboca en errores de +desbordamiento de pila. Por lo tanto se prueba con un esquema híbrido, poniendo un límite a la recursividad, volviendo al algoritmo iterativo cuando se alcanza este límite. @@ -924,9 +923,9 @@ sobre el algoritmo original (ver :ref:`dgc_algo_mark`):: Al analizar los resultados de de esta modificación, se observa una mejoría muy level, para valores de ``MAX_DEPTH`` mayores a cero (en algunos casos bastante -mayores) y en general para ``MAX_DEPTH`` cero (es decir, usando el algoritmo -de forma completamente iterativa) los resultados son peores, dado que se paga -el trabajo extra sin ganancia alguna. En la figura :vref:`fig:sol-mark-rec` se +mayores). En general para ``MAX_DEPTH`` cero (es decir, usando el algoritmo de +forma completamente iterativa) los resultados son peores, dado que se paga el +trabajo extra sin ganancia alguna. En la figura :vref:`fig:sol-mark-rec` se puede ver, por ejemplo, el tiempo total de ejecución de Dil_ al generar la documentación completa del código de Tango_, según varía el valor de ``MAX_DEPTH``. @@ -950,7 +949,7 @@ programa que esté al borde de consumir todo el *stack*, el recolector podría hacer fallar al programa de una forma inesperada para el usuario, problema que sería muy difícil de depurar para éste), y que los resultados obtenidos no son rotundamente superiores a los resultados sin esta modificación, se opta por no -incluir este cambio. Tampoco vale la pena incluirlo como una opción con valor +incluir el cambio. Tampoco vale la pena incluirlo como una opción con valor por omisión 0 porque, como se ha dicho, para este caso el resultado es incluso peor que sin la modificación. @@ -971,8 +970,8 @@ recolección de estadísticas. Hay muchos aspectos que pueden ser analizados a la hora de evaluar un recolector, y es por esto que se busca que la recolección de datos sea lo más completa posible. -Con este objetivo, se decide recolectar datos sobre lo que, probablemente, -sean las operaciones más importantes del recolector: asignación de memoria +Con este objetivo, se decide recolectar datos sobre lo que probablemente sean +las operaciones más importantes del recolector: asignación de memoria y recolección. Todos los datos recolectados son almacenados en archivos que se especifican @@ -1028,7 +1027,7 @@ interés para analizar como se comporta el recolector. El punto 8 es completamente inútil, ya que el compilador nunca provee esta información, pero se la deja por si en algún momento comienza a hacerlo. Los -puntos 9 a 12 provee información sobre el tipo del objeto almacenado, útil +puntos 9 a 12 proveen información sobre el tipo del objeto almacenado, útil para un marcado preciso (ver :ref:`sol_precise`). El punto 6 indica, indirectamente, cuales de los objetos asignados son @@ -1050,12 +1049,12 @@ recolección [#solcollect]_ (es decir, cada vez que se llama a la función *stop-the-world*). 5. Cantidad de memoria usada antes de la recolección. 6. Cantidad de memoria libre antes de la recolección. -7. Cantidad de memoria desperdiciada antes de la recolección. +7. Cantidad de memoria desperdiciada [#solwaste]_ antes de la recolección. 8. Cantidad de memoria utilizada por el mismo recolector antes de la recolección (para sus estructuras internas). 9. Cantidad de memoria usada después de la recolección. 10. Cantidad de memoria libre después de la recolección. -11. Cantidad de memoria desperdiciada [#solwaste]_ después de la recolección. +11. Cantidad de memoria desperdiciada después de la recolección. 12. Cantidad de memoria utilizada por el mismo recolector después de la recolección. @@ -1085,11 +1084,11 @@ Marcado preciso ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Para agregar el soporte de marcado preciso se aprovecha el trabajo realizado -por Vincent Lang (ver :ref:`dgc_via_art`) [DBZ3463]_, dado que se basa en `D -1.0`_ y Tango_, al igual que este trabajo. Dado el objetivo y entorno común, -se abre la posibilidad de adaptar sus cambios a este trabajo, utilizando una -versión modificada de DMD_ (dado que los cambios aún no son integrados al -compilador oficial). +por Vincent Lang (ver :ref:`dgc_via_art`) [DBZ3463]_, gracias a que se basa en +`D 1.0`_ y Tango_, al igual que este trabajo. Dado el objetivo y entorno +común, se abre la posibilidad de adaptar sus cambios a este trabajo, +utilizando una versión modificada de DMD_ (dado que los cambios aún no están +integrados al compilador oficial todavía). .. TODO: Apéndice con parches a DMD y Tango? @@ -1255,7 +1254,7 @@ objeto ocupará el doble de memoria. El algoritmo de marcado se cambia de la siguiente forma:: // Agregado - global conservative_scan = [1, 1, 0] + global conservative_ptrmap = [1, 1, 0] // Agregado function must_scan_word(pos, bits) is @@ -1267,7 +1266,7 @@ El algoritmo de marcado se cambia de la siguiente forma:: pointer = begin while pointer < end foreach word_pos in 0..number_of_words_in_type // - if not must_scan_word(n, scan_bits) // Agregado + if not must_scan_word(word_pos, scan_bits) // Agregado continue // [pool, page, block] = find_block(pointer) if block is not null and block.mark is false @@ -1292,7 +1291,7 @@ El algoritmo de marcado se cambia de la siguiente forma:: else // objeto pequeño // begin = block.begin // end = block.end // Modificado - ptrmap = global conservative_scan // + ptrmap = global conservative_ptrmap // if NO_SCAN not in block.attrs // end -= size_t.sizeof // ptrmap = cast(size_t*) *end // @@ -1300,17 +1299,17 @@ El algoritmo de marcado se cambia de la siguiente forma:: function mark_static_data() is mark_range(static_data.begin, static_data.end, - global conservative_scan) // Agregado + global conservative_ptrmap) // Agregado function mark_stacks() is foreach thread in threads mark_range(thread.stack.begin, thread.stack.end, - global conservative_scan) // Agregado + global conservative_ptrmap) // Agregado function mark_user_roots() is foreach root_range in user_roots mark_range(root_range.begin, root_range.end, - global conservative_scan) // Agregado + global conservative_ptrmap) // Agregado Las funciones de asignación de memoria se modifican de forma similar, para guardar el puntero a la información de tipos. Esta implementación utiliza solo @@ -1388,7 +1387,7 @@ puede ser muy eficiente, y la copia de memoria es proporcional a la cantidad de cambios que hayan. :manpage:`fork(2)` tiene otra propiedad importante de mencionar: detiene todos -los hilos de ejecución en el proceso hijo. Es decir, el proceso hijo se crear +los hilos de ejecución en el proceso hijo. Es decir, el proceso hijo se crea con un solo hilo (el hilo que ejecutó la operación de :manpage:`fork(2)`). Algoritmo @@ -1397,7 +1396,7 @@ Lo que propone el algoritmo es muy sencillo, utilizar la llamada al sistema :manpage:`fork(2)` para crear una *fotografía* de la memoria del proceso en un nuevo proceso. En el proceso padre sigue corriendo el *mutator* y en el proceso hijo se corre la fase de marcado. El *mutator* puede modificar el -grafo de conectividad pero los cambios quedan aislados el hijo (el marcado), +grafo de conectividad pero los cambios quedan aislados del hijo (el marcado), que tiene una visión consistente e inmutable de la memoria. El sistema operativo duplica las páginas que modifica el padre bajo demanda, por lo tanto la cantidad de memoria física realmente copiada es proporcional a la cantidad @@ -1412,17 +1411,16 @@ se preserva: Es decir, el *mutator* no puede *resucitar* una celda *muerta* y esta invariante se mantiene al correr la fase de marcado sobre una vista inmutable de la memoria. El único efecto introducido es que el algoritmo toma una -aproximación más conservativa. Es decir, lo que sí puede pasar es que una -celda que pasó a estar *muerta* una vez que la fase de marcado se inició, pero -antes de que ésta termine, la celda no se reciclará hasta la próxima -recolección, dado que este algoritmo no incluye una comunicación entre -*mutator* y recolector para notificar cambios en el grafo de conectividad. -Pero esto no afecta la corrección del algoritmo, ya que un recolector es -correcto cuando nunca recicla celdas *vivas*. +aproximación más conservativa; una celda que pasó a estar *muerta* luego de +que se inicie la fase de marcado, pero antes de que termine, puede no ser +reciclada hasta la próxima recolección, dado que este algoritmo no incluye una +comunicación entre *mutator* y recolector para notificar cambios en el grafo +de conectividad. Pero esto no afecta la corrección del algoritmo, ya que un +recolector es correcto cuando nunca recicla celdas *vivas*. La única comunicación necesaria entre el *mutator* y el recolector son los bits de marcado (ver :ref:`dgc_impl`), dado que la fase de barrido debe correr -en el proceso padre. No es necesaria ningún tipo de sincronización entre +en el proceso padre. No es necesario ningún tipo de sincronización entre *mutator* y recolector más allá de que uno espera a que el otro finalice. Además de almacenar el conjunto de bits ``mark`` en memoria compartida entre @@ -1667,8 +1665,8 @@ empezar la fase de marcado no sean barridas por tener ese bit activo:: block.mark = true // return pool -Finalmente, el punto número tres puede ser solucionado con el siguiente -pequeño cambio:: +Finalmente, el punto número 3 puede ser solucionado con el siguiente pequeño +cambio:: funciones new_pool(number_of_pages = 1) is pool = alloc(pool.sizeof) @@ -1697,7 +1695,7 @@ recolectada por la fase de barrido cuando termine el marcado). Estas modificaciones son las que hacen que el algoritmo siga siendo correcto, asegurando que no se van a liberar celdas *vivas* (a expensas de diferir la -liberación de algunas celdas *muertas* por algún tiempo). +liberación de algunas celdas *muertas* por un tiempo). .. _sol_early_collect: @@ -1711,9 +1709,9 @@ recolección es controlado por la opción ``min_free`` (ver :ref:`sol_ocup`). De esta forma también puede correr de forma realmente concurrente el *mutator* y el recolector, al menos hasta que se acabe la memoria, en cuyo caso, a menos -que la opción ``eager_alloc`` (ver :ref:`sol_eager_alloc`) también esté -activada, se deberá esperar a que la fase de marcado termine para recuperar -memoria en la fase de barrido. +que la opción ``eager_alloc`` también esté activada (ver +:ref:`sol_eager_alloc`), se deberá esperar a que la fase de marcado termine +para recuperar memoria en la fase de barrido. Para facilitar la comprensión de esta mejora se muestran sólo los cambios necesarios si no se utiliza la opción ``eager_alloc``:: @@ -1842,7 +1840,7 @@ opciones del compilador DMD_: ``-release`` No genera el código para verificar pre y post-condiciones, invariantes de representación, operaciones fuera de los límites de un arreglo y - *assert*\ 's en general (ver :ref:`d_dbc`). + *assert*\ s en general (ver :ref:`d_dbc`). Parámetros de los programas ^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -1860,19 +1858,18 @@ que se especifique lo contrario), que se detallan a continuación. ``concpu`` ``40 4 bible.txt`` - Procesa 40 veces un archivo de texto plano (de 4MiB de tamaño) [#solbible]_ - utilizando 4 hilos (más el principal). + Procesa 40 veces un archivo de texto plano (de 4MiB de tamaño) utilizando + 4 hilos (más el principal). ``split`` ``bible.txt 2`` - Procesa dos veces un archivo de texto plano (de 4MiB de tamaño) - [#solbible]_. + Procesa dos veces un archivo de texto plano (de 4MiB de tamaño). ``sbtree`` ``16`` - Construyen árboles con profundidad máxima 16. + Construye árboles con profundidad máxima 16. ``bh`` ``-b 4000`` @@ -1882,7 +1879,7 @@ que se especifique lo contrario), que se detallan a continuación. ``bisort`` ``-s 2097151`` - Ordena alrededor de 2 millones de números (exactamente :math:`2^21 + Ordena alrededor de 2 millones de números (exactamente :math:`2^{21} = 2097151`). ``em3d`` @@ -2037,7 +2034,7 @@ que ya había una en curso. Además, ciertas pruebas se corren variando la cantidad de procesadores utilizados, para medir el impacto de la concurrencia en ambientes con un procesador solo y con múltiples procesadores. Para esto se utiliza el comando -:manpage:`taskset`, que establece la *afinidad* de un proceso, *atándolo* +:manpage:`taskset(1)`, que establece la *afinidad* de un proceso, *atándolo* a correr en un cierto conjunto de procesadores. Si bien las pruebas se realizan utilizando 1, 2, 3 y 4 procesadores, los resultados presentados en general se limitan a 1 y 4 procesadores, ya que no se observan diferencias @@ -2369,7 +2366,8 @@ copiar tablas de memoria más grandes al efectuar el *fork* (ver En la figura :vref:`fig:sol-concpu-1cpu` se pueden observar los resultados para ``concpu`` al utilizar un solo procesador. En ella se aprecia que el tiempo total de ejecución disminuye levemente al usar marcado concurrente -mientras no se utilice *eager allocation* pero aumenta al utilizarlo. +mientras no se utilice *eager allocation* (si se utiliza vuelve a aumentar, +incluso más que sin marcado concurrente). Con respecto a la cantidad de recolecciones, uso máximo de memoria y tiempo de *stop-the-world* se ve un efecto similar al descripto para ``bigarr`` (aunque @@ -2697,8 +2695,8 @@ Los efectos observados (en la figura :vref:`fig:sol-mcore-1cpu` para al ser una suma de los efectos observados para ``concpu`` y ``split``, con el agregado de una particularidad extra por la mencionada competencia entre hilos. A diferencia de ``concpu`` donde el incremento de procesadores resulta -en un decremento en el tiempo total de ejecución, en este caso resulta en una -disminución, dado que se necesita mucha sincronización entre hilos, por +en un decremento en el tiempo total de ejecución, en este caso resulta en un +incremento, dado que se necesita mucha sincronización entre hilos, por utilizar todos de forma intensiva los servicios del recolector (y por lo tanto competir por su *lock* global). @@ -2952,7 +2950,7 @@ similares a los obtenidos utilizando solo uno. ^^^^^^^^ Los resultados para ``em3d`` (figura :vref:`fig:sol-em3d-1cpu`) son sorprendentemente similares a los de ``bisort``. La única diferencia es que en -este caso el marcado preciso y el uso de *early collection** no parecen +este caso el marcado preciso y el uso de *early collection* no parecen ayudar; por el contrario, aumentan levemente el tiempo de pausa real. Una vez más no se muestran los resultados para más de un procesador por ser @@ -3253,11 +3251,11 @@ del *heap*; se recuerda que el *stack* y memoria estática se siguen marcado de forma conservativa, incluso en modo preciso. También se puede observar una gran disminución del tiempo total de ejecución -(cerca de un 60%, y más de un 200% comparado con TBGC) alrededor de la mitad) -al empezar a usar *eager allocation*, acompañado como es usual de una baja en -la cantidad de recolecciones realizadas (esta vez mayor, de más de 3 veces) -y de una caída drástica del tiempo de pausa real (alrededor de 40 veces más -pequeño); todo esto con un incremento marginal en el consumo total de memoria +al empezar a usar *eager allocation* (cerca de un 60%, y más de un 200% +comparado con TBGC), acompañado como es usual de una baja en la cantidad de +recolecciones realizadas (esta vez mayor, de más de 3 veces) y de una caída +drástica del tiempo de pausa real (alrededor de 40 veces más pequeño); todo +esto con un incremento marginal en el consumo total de memoria (aproximadamente un 5%). En este caso el uso de *early collection* apenas ayuda a bajar el tiempo de pausa real en un 20% en promedio aproximadamente. El tiempo de *stop-the-world* cae dramáticamente al empezar a realizar la fase @@ -3284,15 +3282,14 @@ buena recepción por parte de la comunidad a las modificaciones propuestas. Una vez agregado el marcado concurrente se hace un anuncio en el grupo de noticias que también muestra buenos comentarios y aceptación, en particular por parte de Sean Kelly, encargado de mantener el *runtime* de `D 2.0`_, que -comienza a trabajar en adaptar el recolector con idea de tal vez incluirlo en -el futuro [NGA19235]_. Poco después Sean Kelly publica una versión preliminar -de la adaptación en la lista de correos que coordina el desarrollo del -*runtime* de `D 2.0`_ [DRT117]_. - -También se ha mostrado interés de incluirlo en Tango_, aunque no se han ha -comenzado aún con la adaptación, pero debería ser trivial dado que este -trabajo se desarrolla usando Tango_ (y el recolector está basado en el de -Tango_) [TT1997]_. +comienza a trabajar en adaptar el recolector con idea de tal vez incluirlo de +manera oficial en el futuro [NGA19235]_. Poco después Sean Kelly publica una +versión preliminar de la adaptación en la lista de correos que coordina el +desarrollo del *runtime* de `D 2.0`_ [DRT117]_. + +También se ha mostrado interés de incluirlo en Tango_, por lo que se han +publicado los cambios necesarios en el sistema de seguimiento de mejoras +y se encuentran actualmente en etapa de revisión [TT1997]_. .. include:: links.rst