Mencionar ionice(1) en la metodología de pruebas

[z.facultad/75.00/informe.git] / source / solucion.rst

diff --git a/source/solucion.rst b/source/solucion.rst
index 2907da2825ec537bd82a538074970cc579bbc5a5..8ddbb353674584903d96a5b3da045518030cf114 100644 (file)
--- a/source/solucion.rst
+++ b/source/solucion.rst
@@ -1,8 +1,4 @@
 
 

-.. Acá va lo que decidí hacer en base al análisis anterior y sus razones.
-   ESTADO: TERMINADO
-
-

 .. _solucion:
 
 Solución adoptada
 .. _solucion:
 
 Solución adoptada


@@ -62,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.
 
 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
 los programas triviales.
 
 .. [#benchmod] Cabe destacar que en general todos los programas recolectados


@@ -105,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
 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;
 
    const IT = 300;
    const N1 = 20_000;


@@ -132,7 +128,6 @@ El código fuente del programa es el siguiente::
 
    int main(char[][] args)
    {
 
    int main(char[][] args)
    {

-

       Population testPop1 = new Population;
       Population testPop2 = new Population;
       Individual[N2] indi;
       Population testPop1 = new Population;
       Population testPop2 = new Population;
       Individual[N2] indi;


@@ -166,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
 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
 
 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


@@ -176,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.
 
 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;
 
    import tango.core.Thread: Thread;
    import tango.core.Atomic: Atomic;


@@ -271,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
 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``
 
 
 ``split``


@@ -284,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]_.
 
 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;
 
    import tango.io.device.File: File;
    import tango.text.Util: delimit;


@@ -311,12 +306,12 @@ __ http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&art
 Este programa fue escrito por Oskar Linde y nuevamente hallado__ en el grupo
 de noticias. Fue construido para mostrar como el hecho de que el recolector
 sea conservativo puede hacer que al leer datos binarios hayan muchos *falsos
 Este programa fue escrito por Oskar Linde y nuevamente hallado__ en el grupo
 de noticias. Fue construido para mostrar como el hecho de que el recolector
 sea conservativo puede hacer que al leer datos binarios hayan muchos *falsos

-punteros* que mantengan vivas celdas que en realidad ya no deberían ser
+positivos* que mantengan vivas celdas que en realidad ya no deberían ser

 accesibles desde el *root set* del grafo de conectividad.
 
 __ http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=46407
 
 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;
 
 
    import tango.math.random.Random;
 


@@ -353,8 +348,8 @@ El código del programa es el siguiente::
 Este programa está basado en la prueba de nombre ``binary-trees`` de `The
 Computer Language Benchmarks Game`__, una colección de 12 programas escritos
 en alrededor de 30 lenguajes de programación para comparar su eficiencia
 Este programa está basado en la prueba de nombre ``binary-trees`` de `The
 Computer Language Benchmarks Game`__, una colección de 12 programas escritos
 en alrededor de 30 lenguajes de programación para comparar su eficiencia

-(medida en tiempo de ejecución, uso de memoria y cantidad de líneas de
-código). De este juego de programas se utilizó solo ``binary-trees`` por ser
+(medida en tiempo de ejecución, uso de memoria y cantidad de líneas de código)
+[SHO10]_. De este juego de programas se utilizó solo ``binary-trees`` por ser

 el único destinado a ejercitar el manejo de memoria. El programa sólo manipula
 árboles binarios, creándolos y recorriéndolos inmediatamente (no realiza
 ningún trabajo útil). La traducción a D_ fue realizada por Andrey Khropov
 el único destinado a ejercitar el manejo de memoria. El programa sólo manipula
 árboles binarios, creándolos y recorriéndolos inmediatamente (no realiza
 ningún trabajo útil). La traducción a D_ fue realizada por Andrey Khropov


@@ -363,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
 
 __ 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;
 
    import tango.util.Convert;
    alias char[] string;


@@ -430,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
 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
 
 __ http://www.irisa.fr/caps/people/truong/M2COct99/Benchmarks/Olden/Welcome.html
 __ http://www.martincarlisle.com/olden.html


@@ -445,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
 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/
 
 __ http://www-ali.cs.umass.edu/DaCapo/benchmarks.html
 __ http://www.dacapobench.org/


@@ -526,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
 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:
 
 
 El programa está compuesto por:
 


@@ -546,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
 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
 
 Por último, a diferencia de muchos otros programas escritos en D_, que dadas
 algunas de las ineficiencias del recolector invierten mucho trabajo en limitar


@@ -625,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
 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
 
 Este esquema provee la mejor relación entre configurabilidad, conveniencia,
 eficiencia y simplicidad. Una posibilidad para lograr esto es utilizar


@@ -668,7 +663,7 @@ interpretado de la siguiente manera (en formato similar a :term:`BNF`):
    name: `namec` `namec`*                <nombre de la opción>
    value: `valuec`*                      <valor de la opción>
    namec: `valuec` - '='
    name: `namec` `namec`*                <nombre de la opción>
    value: `valuec`*                      <valor de la opción>
    namec: `valuec` - '='

-   valuec: [0x01-0xFF] - ':'             <cualquier char salvo '\0' y ':'>
+   valuec: [0x01-0xFF] - ':'             <cualquiera salvo '\0' y ':'>

 
 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
 
 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


@@ -702,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
    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``
 
 ``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
 
 ``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
 
 ``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
 
 ``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
 
 ``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
 
 ``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
 
 ``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,
 
 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,


@@ -760,7 +755,7 @@ shell*):
 
 .. code-block:: none
 
 
 .. 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
 
 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


@@ -852,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
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 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
 
 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


@@ -886,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
 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, se 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.
 
 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.


@@ -928,17 +923,17 @@ 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
 
 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``.
 
 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``.
 

-.. fig:: fig:sol-mark-rec
+.. flt:: fig:sol-mark-rec

 
    Análisis de tiempo total de ejecución en función del valor de
 
    Análisis de tiempo total de ejecución en función del valor de

-   ``MAX_DEPTH``.
+   ``MAX_DEPTH``

 
    Tiempo total de ejecución de Dil_ al generar la documentación completa del
    código de Tango_ en función del valor de ``MAX_DEPTH``. El rombo no
 
    Tiempo total de ejecución de Dil_ al generar la documentación completa del
    código de Tango_ en función del valor de ``MAX_DEPTH``. El rombo no


@@ -954,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
 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.
 
 por omisión 0 porque, como se ha dicho, para este caso el resultado es incluso
 peor que sin la modificación.
 


@@ -975,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.
 
 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
 y recolección.
 
 Todos los datos recolectados son almacenados en archivos que se especifican


@@ -1032,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
 
 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
 para un marcado preciso (ver :ref:`sol_precise`).
 
 El punto 6 indica, indirectamente, cuales de los objetos asignados son


@@ -1054,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.
    *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.
 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.
 
 12. Cantidad de memoria utilizada por el mismo recolector después de la
     recolección.
 


@@ -1089,11 +1084,11 @@ Marcado preciso
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Para agregar el soporte de marcado preciso se aprovecha el trabajo realizado
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 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?
 
 
 .. TODO: Apéndice con parches a DMD y Tango?
 


@@ -1105,9 +1100,10 @@ memoria. Esta información se pasa como un puntero a un arreglo de palabras con
 la estructura mostrada en la figura :vref:`fig:sol-ptrmap` y que se describe
 a continuación.
 
 la estructura mostrada en la figura :vref:`fig:sol-ptrmap` y que se describe
 a continuación.
 

-.. fig:: fig:sol-ptrmap
+.. flt:: fig:sol-ptrmap
+   :type: table

 
 

-   Estructura de la información de tipos provista por el compilador.
+   Estructura de la información de tipos provista por el compilador

 
    .. aafig::
       :scale: 110
 
    .. aafig::
       :scale: 110


@@ -1169,9 +1165,9 @@ palabra sea realmente un puntero, pero indica que debe ser escaneado. El
 recolector debe debe ser conservativo en este caso, y escanear esa palabra
 como si fuera un puntero.
 
 recolector debe debe ser conservativo en este caso, y escanear esa palabra
 como si fuera un puntero.
 

-.. fig:: fig:sol-ptrmap-example
+.. flt:: fig:sol-ptrmap-example

 
 

-   Ejemplo de estructura de información de tipos generada para el tipo ``S``.
+   Ejemplo de estructura de información de tipos generada para el tipo ``S``

 
    .. aafig::
       :textual:
 
    .. aafig::
       :textual:


@@ -1229,10 +1225,10 @@ ese caso no hace falta directamente escanear ninguna palabra del bloque.
 En la figura :vref:`fig:sol-ptrmap-blk` se puede ver, como continuación del
 ejemplo anterior, como se almacenaría en memoria un objeto del tipo ``S``.
 
 En la figura :vref:`fig:sol-ptrmap-blk` se puede ver, como continuación del
 ejemplo anterior, como se almacenaría en memoria un objeto del tipo ``S``.
 

-.. fig:: fig:sol-ptrmap-blk
+.. flt:: fig:sol-ptrmap-blk

 
    Ejemplo de bloque que almacena un objeto de tipo ``S`` con información de
 
    Ejemplo de bloque que almacena un objeto de tipo ``S`` con información de

-   tipo.
+   tipo

 
    .. aafig::
       :scale: 110
 
    .. aafig::
       :scale: 110


@@ -1258,7 +1254,7 @@ objeto ocupará el doble de memoria.
 El algoritmo de marcado se cambia de la siguiente forma::
 
    // Agregado
 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
 
    // Agregado
    function must_scan_word(pos, bits) is


@@ -1270,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   //
       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
                continue                                   //
             [pool, page, block] = find_block(pointer)
             if block is not null and block.mark is false


@@ -1295,7 +1291,7 @@ El algoritmo de marcado se cambia de la siguiente forma::
                         else // objeto pequeño                   //
                            begin = block.begin                   //
                            end = block.end                       // Modificado
                         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           //
                         if NO_SCAN not in block.attrs            //
                            end -= size_t.sizeof                  //
                            ptrmap = cast(size_t*) *end           //


@@ -1303,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,
 
    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,
 
    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,
 
    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
 
 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


@@ -1391,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
 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
 con un solo hilo (el hilo que ejecutó la operación de :manpage:`fork(2)`).
 
 Algoritmo


@@ -1400,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
 :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
 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


@@ -1415,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
 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
 
 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
 *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


@@ -1523,8 +1518,8 @@ ser las siguientes::
             sweep()                             //
          return                                 //
       stop_the_world()
             sweep()                             //
          return                                 //
       stop_the_world()

-      child_pid = fork()

       fflush(null)
       fflush(null)

+      child_pid = fork()

       if child_pid is 0 // proceso hijo
          mark_phase()
          exit(0)
       if child_pid is 0 // proceso hijo
          mark_phase()
          exit(0)


@@ -1670,8 +1665,8 @@ empezar la fase de marcado no sean barridas por tener ese bit activo::
             block.mark = true       //
       return pool
 
             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)
 
    funciones new_pool(number_of_pages = 1) is
       pool = alloc(pool.sizeof)


@@ -1700,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
 
 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:
 
 
 .. _sol_early_collect:


@@ -1714,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
 
 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``::
 
 Para facilitar la comprensión de esta mejora se muestran sólo los cambios
 necesarios si no se utiliza la opción ``eager_alloc``::


@@ -1845,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
 ``-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
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Parámetros de los programas
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^


@@ -1863,19 +1858,18 @@ que se especifique lo contrario), que se detallan a continuación.
 ``concpu``
    ``40 4 bible.txt``
 
 ``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``
 
 
 ``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``
 
 
 ``sbtree``
    ``16``
 

-   Construyen árboles con profundidad máxima 16.
+   Construye árboles con profundidad máxima 16.

 
 ``bh``
    ``-b 4000``
 
 ``bh``
    ``-b 4000``


@@ -1885,7 +1879,7 @@ que se especifique lo contrario), que se detallan a continuación.
 ``bisort``
    ``-s 2097151``
 
 ``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``
    = 2097151`).
 
 ``em3d``


@@ -2040,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
 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
 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


@@ -2054,37 +2048,10 @@ En los casos donde se utilizan otro tipo de métricas para evaluar aspectos
 particulares sobre alguna modificación se describe como se realiza la medición
 donde se utiliza la métrica especial.
 
 particulares sobre alguna modificación se describe como se realiza la medición
 donde se utiliza la métrica especial.
 

-Variabilidad de los resultados entre ejecuciones
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Es de esperarse que haya una cierta variación en los resultados entre
-corridas, dada la indeterminación inherente a los sistemas operativos de
-tiempo compartido, que compiten por los recursos de la computadora.
-
-Para minimizar esta variación se utilizan varias herramientas. En primer
-lugar, se corren las pruebas estableciendo máxima prioridad (-19 en Linux_) al
-proceso utilizando el comando :manpage:`nice(1)`. La variación en la
-frecuencia del reloj los procesadores (para ahorrar energía) puede ser otra
-fuente de variación, por lo que se usa el comando :manpage:`cpufreq-set(1)`
-para establecer la máxima frecuencia disponible de manera fija.
+.. flt:: t:sol-setarch
+   :type: table

 
 

-Sin embargo, a pesar de tomar estas precauciones, se sigue observando una
-amplia variabilidad entre corridas. Además se observa una variación más
-importante de la esperada no solo en el tiempo, también en el consumo de
-memoria, lo que es más extraño. Esta variación se debe principalmente a que
-Linux_ asigna el espacio de direcciones a los procesos con una componente
-azarosa (por razones de seguridad). Además, por omisión, la llamada al sistema
-:manpage:`mmap(2)` asigna direcciones de memoria altas primero, entregando
-direcciones más bajas en llamadas subsiguientes [LWN90311]_.
-
-El comando :manpage:`setarch(8)` sirve para controlar éste y otros aspectos de
-Linux_. La opción ``-L`` hace que se utilice un esquema de asignación de
-direcciones antiguo, que no tiene una componente aleatoria y asigna primero
-direcciones bajas. La opción ``-R`` solamente desactiva la componente azarosa
-al momento de asignar direcciones.
-
-.. ftable:: t:sol-setarch
-
-   Variación entre corridas para TBGC.
+   Variación entre corridas para TBGC

 
    Variación entre corridas para TBGC. La medición está efectuada utilizando
    los valores máximo, mínimo y media estadística de 20 corridas, utilizando
 
    Variación entre corridas para TBGC. La medición está efectuada utilizando
    los valores máximo, mínimo y media estadística de 20 corridas, utilizando


@@ -2092,7 +2059,7 @@ al momento de asignar direcciones.
    realizarse utilizando el desvío estándar en vez de la amplitud máxima, pero
    en este cuadro se quiere ilustrar la variación máxima, no la típica.
 
    realizarse utilizando el desvío estándar en vez de la amplitud máxima, pero
    en este cuadro se quiere ilustrar la variación máxima, no la típica.
 

-   .. subtable::
+   .. subflt::

 
       Del tiempo total de ejecución.
 
 
       Del tiempo total de ejecución.
 


@@ -2114,7 +2081,7 @@ al momento de asignar direcciones.
       voronoi  0.886    0.003    0.006
       ======== ======== ======== ========
 
       voronoi  0.886    0.003    0.006
       ======== ======== ======== ========
 

-   .. subtable::
+   .. subflt::

 
       Del consumo máximo de memoria.
 
 
       Del consumo máximo de memoria.
 


@@ -2136,136 +2103,168 @@ al momento de asignar direcciones.
       voronoi  0.001    0.000    0.000
       ======== ======== ======== ========
 
       voronoi  0.001    0.000    0.000
       ======== ======== ======== ========
 

-Ambas opciones, reducen notablemente la variación en los resultados (ver
-cuadro :vref:`t:sol-setarch`). Esto probablemente se debe a la naturaleza
-conservativa del recolector, dado que la probabilidad de tener *falsos
-punteros* depende directamente de los valores de las direcciones de memoria,
-aunque las pruebas en la que hay concurrencia involucrada, se siguen viendo
-grandes variaciones, que probablemente estén vinculadas a problemas de
-sincronización que se ven expuestos gracias al indeterminismo inherente a los
-programas multi-hilo.
-
-Si bien se obtienen resultados más estables utilizando un esquema diferente al
-utilizado por omisión, se decide no hacerlo dado que las mediciones serían
-menos realistas. Los usuarios en general no usan esta opción y se presentaría
-una visión más acotada sobre el comportamiento de los programas. Sin embargo,
-para evaluar el este efecto en los resultados, siempre que sea posible se
-analizan los resultados de un gran número de corridas observando
-principalmente su mínima, media, máxima y desvío estándar.
-
-
+.. flt:: fig:sol-bigarr-1cpu

 
 

-Resultados para pruebas sintizadas
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-A continuación se presentan los resultados obtenidos para las pruebas
-sintetizadas (ver :ref:`sol_bench_synth`). Se recuerda que este conjunto de
-resultados es útil para analizar ciertos aspectos puntuales de las
-modificaciones propuestas, pero en general distan mucho de como se comporta un
-programa real, por lo que los resultados deben ser analizados teniendo esto
-presente.
-
-``bigarr``
-^^^^^^^^^^
-.. fig:: fig:sol-bigarr-1cpu
-
-   Resultados para ``bigarr`` (utilizando 1 procesador).
+   Resultados para ``bigarr`` (utilizando 1 procesador)

 
    Resultados para ``bigarr`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``bigarr`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-bigarr-1cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-bigarr-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-bigarr-1cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-bigarr-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-bigarr-1cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-bigarr-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-bigarr-1cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-bigarr-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-bigarr-1cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-bigarr-1cpu.pdf
 

-.. fig:: fig:sol-bigarr-4cpu
+Variabilidad de los resultados entre ejecuciones
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Es de esperarse que haya una cierta variación en los resultados entre
+corridas, dada la indeterminación inherente a los sistemas operativos de
+tiempo compartido, que compiten por los recursos de la computadora.
+
+Para minimizar esta variación se utilizan varias herramientas. En primer
+lugar, se corren las pruebas estableciendo máxima prioridad (-19 en Linux_) al
+proceso utilizando el comando :manpage:`nice(1)`. La variación en la
+frecuencia del reloj los procesadores (para ahorrar energía) puede ser otra
+fuente de variación, por lo que se usa el comando :manpage:`cpufreq-set(1)`
+para establecer la máxima frecuencia disponible de manera fija. El acceso
+a disco, en las pruebas que utilizan archivos, puede ser otro factor
+importante, por lo tanto se utiliza :manpage:`ionice(1)` para darle prioridad
+de entrada/salida de tiempo real al proceso y se realizan las pruebas con el
+caché de disco en *caliente*.
+
+Sin embargo, a pesar de tomar estas precauciones, se sigue observando una
+amplia variabilidad entre corridas. Además se observa una variación más
+importante de la esperada no solo en el tiempo, también en el consumo de
+memoria, lo que es más extraño. Esta variación se debe principalmente a que
+Linux_ asigna el espacio de direcciones a los procesos con una componente
+azarosa (por razones de seguridad). Además, por omisión, la llamada al sistema
+:manpage:`mmap(2)` asigna direcciones de memoria altas primero, entregando
+direcciones más bajas en llamadas subsiguientes [LWN90311]_.
+
+El comando :manpage:`setarch(8)` sirve para controlar éste y otros aspectos de
+Linux_. La opción ``-L`` hace que se utilice un esquema de asignación de
+direcciones antiguo, que no tiene una componente aleatoria y asigna primero
+direcciones bajas. La opción ``-R`` solamente desactiva la componente azarosa
+al momento de asignar direcciones.
+
+Ambas opciones, reducen notablemente la variación en los resultados (ver
+cuadro :vref:`t:sol-setarch`). Esto probablemente se debe a la naturaleza
+conservativa del recolector, dado que la probabilidad de tener *falsos
+positivos* depende directamente de los valores de las direcciones de memoria,
+aunque las pruebas en la que hay concurrencia involucrada, se siguen viendo
+grandes variaciones, que probablemente estén vinculadas a problemas de
+sincronización que se ven expuestos gracias al indeterminismo inherente a los
+programas multi-hilo.
+
+Si bien se obtienen resultados más estables utilizando un esquema diferente al
+utilizado por omisión, se decide no hacerlo dado que las mediciones serían
+menos realistas. Los usuarios en general no usan esta opción y se presentaría
+una visión más acotada sobre el comportamiento de los programas. Sin embargo,
+para evaluar el este efecto en los resultados, siempre que sea posible se
+analizan los resultados de un gran número de corridas observando
+principalmente su mínima, media, máxima y desvío estándar.
+
+

 
 

-   Resultados para ``bigarr`` (utilizando 4 procesadores).
+Resultados para pruebas sintizadas
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A continuación se presentan los resultados obtenidos para las pruebas
+sintetizadas (ver :ref:`sol_bench_synth`). Se recuerda que este conjunto de
+resultados es útil para analizar ciertos aspectos puntuales de las
+modificaciones propuestas, pero en general distan mucho de como se comporta un
+programa real, por lo que los resultados deben ser analizados teniendo esto
+presente.
+
+``bigarr``
+^^^^^^^^^^
+En la figura :vref:`fig:sol-bigarr-1cpu` se pueden observar los resultados
+para ``bigarr`` al utilizar un solo procesador. En ella se puede notar que el
+tiempo total de ejecución en general aumenta al utilizar CDGC, esto es
+esperable, dado esta prueba se limitan a usar servicios del recolector. Dado
+que esta ejecución utiliza solo un procesador y por lo tanto no se puede sacar
+provecho a la concurrencia, es de esperarse que el trabajo extra realizado por
+las modificaciones se vea reflejado en los resultados. En la
+:vref:`fig:sol-bigarr-4cpu` (resultados al utilizar 4 procesadores) se puede
+observar como al usar solamente *eager allocation* se recupera un poco el
+tiempo de ejecución, probablemente debido al incremento en la concurrencia
+(aunque no se observa el mismo efecto al usar *early collection*).
+
+Observando el tiempo total de ejecución, no se esperaba un incremento tan
+notorio al pasar de TBGC a una configuración equivalente de CDGC **cons**,
+haciendo un breve análisis de las posibles causas, lo más probable parece ser
+el incremento en la complejidad de la fase de marcado dada capacidad para
+marcar de forma precisa (aunque no se use la opción, se paga el precio de la
+complejidad extra y sin obtener los beneficios).  Además se puede observar
+como el agregado de precisión al marcado mejora un poco las cosas (donde sí se
+obtiene rédito de la complejidad extra en el marcado).
+
+.. flt:: fig:sol-bigarr-4cpu
+
+   Resultados para ``bigarr`` (utilizando 4 procesadores)

 
    Resultados para ``bigarr`` (utilizando 4 procesadores). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``bigarr`` (utilizando 4 procesadores). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-bigarr-4cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-bigarr-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-bigarr-4cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-bigarr-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-bigarr-4cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-bigarr-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-bigarr-4cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-bigarr-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-bigarr-4cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-bigarr-4cpu.pdf
 

-En la figura :vref:`fig:sol-bigarr-1cpu` se pueden observar los resultados
-para ``bigarr`` al utilizar un solo procesador. En ella se puede notar que el
-tiempo total de ejecución en general aumenta al utilizar CDGC, esto es
-esperable, dado esta prueba se limitan a usar servicios del recolector. Dado
-que esta ejecución utiliza solo un procesador y por lo tanto no se puede sacar
-provecho a la concurrencia, es de esperarse que el trabajo extra realizado por
-las modificaciones se vea reflejado en los resultados. En la
-:vref:`fig:sol-bigarr-4cpu` (resultados al utilizar 4 procesadores) se puede
-observar como al usar solamente *eager allocation* se recupera un poco el
-tiempo de ejecución, probablemente debido al incremento en la concurrencia
-(aunque no se observa el mismo efecto al usar *early collection*).
-
-Observando el tiempo total de ejecución, no se esperaba un incremento tan
-notorio al pasar de TBGC a una configuración equivalente de CDGC **cons**,
-haciendo un breve análisis de las posibles causas, lo más probable parece ser
-el incremento en la complejidad de la fase de marcado dada capacidad para
-marcar de forma precisa (aunque no se use la opción, se paga el precio de la
-complejidad extra y sin obtener los beneficios).  Además se puede observar
-como el agregado de precisión al marcado mejora un poco las cosas (donde sí se
-obtiene rédito de la complejidad extra en el marcado).
-

 En general se observa que al usar *eager allocation* el consumo de memoria
 y los tiempos de pausa se disparan mientras que la cantidad de recolecciones
 disminuye drásticamente. Lo que se observa es que el programa es
 En general se observa que al usar *eager allocation* el consumo de memoria
 y los tiempos de pausa se disparan mientras que la cantidad de recolecciones
 disminuye drásticamente. Lo que se observa es que el programa es


@@ -2284,90 +2283,95 @@ incremento en el consumo de memoria, ya que el sistema operativo tiene que
 copiar tablas de memoria más grandes al efectuar el *fork* (ver
 :ref:`sol_fork`).
 
 copiar tablas de memoria más grandes al efectuar el *fork* (ver
 :ref:`sol_fork`).
 

-``concpu``
-^^^^^^^^^^
-.. fig:: fig:sol-concpu-1cpu
+.. raw:: latex
+
+   \clearpage

 
 

-   Resultados para ``concpu`` (utilizando 1 procesador).
+.. flt:: fig:sol-concpu-1cpu
+
+   Resultados para ``concpu`` (utilizando 1 procesador)

 
    Resultados para ``concpu`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``concpu`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-concpu-1cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-concpu-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-concpu-1cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-concpu-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-concpu-1cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-concpu-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-concpu-1cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-concpu-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-concpu-1cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-concpu-1cpu.pdf
 

-.. fig:: fig:sol-concpu-4cpu
+.. flt:: fig:sol-concpu-4cpu

 
 

-   Resultados para ``concpu`` (utilizando 4 procesadores).
+   Resultados para ``concpu`` (utilizando 4 procesadores)

 
    Resultados para ``concpu`` (utilizando 4 procesadores). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``concpu`` (utilizando 4 procesadores). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-concpu-4cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-concpu-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-concpu-4cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-concpu-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-concpu-4cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-concpu-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-concpu-4cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-concpu-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-concpu-4cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-concpu-4cpu.pdf
 

+``concpu``
+^^^^^^^^^^

 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
 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
 
 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


@@ -2408,143 +2412,143 @@ Sin embargo, no se encuentra una razón clara para explicar el crecimiento
 dramático en la cantidad de recolecciones solo al no usar marcado concurrente
 para 4 procesadores.
 
 dramático en la cantidad de recolecciones solo al no usar marcado concurrente
 para 4 procesadores.
 

-``conalloc``
-^^^^^^^^^^^^
-.. fig:: fig:sol-conalloc-1cpu
+.. flt:: fig:sol-conalloc-1cpu

 
 

-   Resultados para ``conalloc`` (utilizando 1 procesador).
+   Resultados para ``conalloc`` (utilizando 1 procesador)

 
    Resultados para ``conalloc`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``conalloc`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-conalloc-1cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-conalloc-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-conalloc-1cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-conalloc-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-conalloc-1cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-conalloc-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-conalloc-1cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-conalloc-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-conalloc-1cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-conalloc-1cpu.pdf
 

-.. fig:: fig:sol-conalloc-4cpu
+.. flt:: fig:sol-conalloc-4cpu

 
 

-   Resultados para ``conalloc`` (utilizando 4 procesadores).
+   Resultados para ``conalloc`` (utilizando 4 procesadores)

 
    Resultados para ``conalloc`` (utilizando 4 procesadores). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``conalloc`` (utilizando 4 procesadores). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-conalloc-4cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-conalloc-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-conalloc-4cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-conalloc-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-conalloc-4cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-conalloc-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-conalloc-4cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-conalloc-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-conalloc-4cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-conalloc-4cpu.pdf
 

-En la figura :vref:`fig:sol-conalloc-1cpu` se pueden observar los resultados
-para ``conalloc`` al utilizar un solo procesador. Los cambios con respecto
-a lo observado para ``concpu`` son mínimos. El efecto de la mejoría al usar
-marcado concurrente pero no *eager allocation* no se observa más, dado que
-``conalloc`` pide memoria en todos los hilos, se crea un cuello de botella. Se
-ve claramente como tampoco baja la cantidad de recolecciones hecha debido
-a esto y se invierte la variabilidad entre los tiempos pico de pausa real
-y *stop-the-world* (sin una razón obvia, pero probablemente relacionado que
-todos los hilos piden memoria).
+.. flt:: fig:sol-split-1cpu

 
 

-Al utilizar 4 procesadores (figura :vref:`fig:sol-conalloc-4cpu`), más allá de
-las diferencias mencionadas para 1 procesador, no se observan grandes cambios
-con respecto a lo observado para ``concpu``, excepto que los tiempos de pausa
-(real y *stop-the-world*) son notablemente más pequeños, lo que pareciera
-confirmar un error en la medición de ``concpu``.
-
-``split``
-^^^^^^^^^
-.. fig:: fig:sol-split-1cpu
-
-   Resultados para ``split`` (utilizando 1 procesador).
+   Resultados para ``split`` (utilizando 1 procesador)

 
    Resultados para ``split`` (utilizando 1 procesador). Se presenta el mínimos
    (en negro), la media centrada entre dos desvíos estándar (en gris), y el
    máximo (en blanco) calculados sobre 50 corridas (para tiempo de ejecución)
    o 20 corridas (para el resto).
 
 
    Resultados para ``split`` (utilizando 1 procesador). Se presenta el mínimos
    (en negro), la media centrada entre dos desvíos estándar (en gris), y el
    máximo (en blanco) calculados sobre 50 corridas (para tiempo de ejecución)
    o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-split-1cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-split-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-split-1cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-split-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-split-1cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-split-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-split-1cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-split-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-split-1cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-split-1cpu.pdf
 

+``conalloc``
+^^^^^^^^^^^^
+En la figura :vref:`fig:sol-conalloc-1cpu` se pueden observar los resultados
+para ``conalloc`` al utilizar un solo procesador. Los cambios con respecto
+a lo observado para ``concpu`` son mínimos. El efecto de la mejoría al usar
+marcado concurrente pero no *eager allocation* no se observa más, dado que
+``conalloc`` pide memoria en todos los hilos, se crea un cuello de botella. Se
+ve claramente como tampoco baja la cantidad de recolecciones hecha debido
+a esto y se invierte la variabilidad entre los tiempos pico de pausa real
+y *stop-the-world* (sin una razón obvia, pero probablemente relacionado que
+todos los hilos piden memoria).
+
+Al utilizar 4 procesadores (figura :vref:`fig:sol-conalloc-4cpu`), más allá de
+las diferencias mencionadas para 1 procesador, no se observan grandes cambios
+con respecto a lo observado para ``concpu``, excepto que los tiempos de pausa
+(real y *stop-the-world*) son notablemente más pequeños, lo que pareciera
+confirmar un error en la medición de ``concpu``.
+
+``split``
+^^^^^^^^^

 Este es el primer caso donde se aprecia la sustancial mejora proporcionada por
 una pequeña optimización, el caché de ``findSize()`` (ver
 :ref:`sol_minor_findsize`). En la figura :vref:`fig:sol-split-1cpu` se puede
 Este es el primer caso donde se aprecia la sustancial mejora proporcionada por
 una pequeña optimización, el caché de ``findSize()`` (ver
 :ref:`sol_minor_findsize`). En la figura :vref:`fig:sol-split-1cpu` se puede


@@ -2563,145 +2567,149 @@ incluso al usar *eager allocation*.
 Se omiten los resultados para más de un procesador por ser prácticamente
 idénticos para este análisis.
 
 Se omiten los resultados para más de un procesador por ser prácticamente
 idénticos para este análisis.
 

-``mcore``
-^^^^^^^^^
-.. fig:: fig:sol-mcore-1cpu
+.. raw:: latex

 
 

-   Resultados para ``mcore`` (utilizando 1 procesador).
+   \clearpage
+
+.. flt:: fig:sol-mcore-1cpu
+
+   Resultados para ``mcore`` (utilizando 1 procesador)

 
    Resultados para ``mcore`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``mcore`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-mcore-1cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-mcore-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-mcore-1cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-mcore-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-mcore-1cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-mcore-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-mcore-1cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-mcore-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-mcore-1cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-mcore-1cpu.pdf
 

-.. fig:: fig:sol-mcore-4cpu
+.. flt:: fig:sol-mcore-4cpu

 
 

-   Resultados para ``mcore`` (utilizando 4 procesadores).
+   Resultados para ``mcore`` (utilizando 4 procesadores)

 
    Resultados para ``mcore`` (utilizando 4 procesadores). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``mcore`` (utilizando 4 procesadores). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-mcore-4cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-mcore-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-mcore-4cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-mcore-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-mcore-4cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-mcore-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-mcore-4cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-mcore-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-mcore-4cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-mcore-4cpu.pdf
 

-El caso de ``mcore`` es interesante por ser, funcionalmente, una combinación
-entre ``concpu`` y ``split``, con un agregado extra: el incremento notable de
-la competencia por utilizar el recolector entre los múltiples hilos.
-
-Los efectos observados (en la figura :vref:`fig:sol-mcore-1cpu` para
-1 procesador y en la figura :vref:`fig:sol-mcore-4cpu` para 4) confirman esto,
-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
-utilizar todos de forma intensiva los servicios del recolector (y por lo tanto
-competir por su *lock* global).
+.. flt:: fig:sol-rnddata-1cpu

 
 

-Otro efecto común observado es que cuando el tiempo de pausa es muy pequeño
-(del orden de los milisegundos), el marcado concurrente suele incrementarlo en
-vez de disminuirlo.
-
-``rnddata``
-^^^^^^^^^^^
-.. fig:: fig:sol-rnddata-1cpu
-
-   Resultados para ``rnddata`` (utilizando 1 procesador).
+   Resultados para ``rnddata`` (utilizando 1 procesador)

 
    Resultados para ``rnddata`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``rnddata`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-rnddata-1cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-rnddata-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-rnddata-1cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-rnddata-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-rnddata-1cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-rnddata-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-rnddata-1cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-rnddata-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-rnddata-1cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-rnddata-1cpu.pdf
 

+``mcore``
+^^^^^^^^^
+El caso de ``mcore`` es interesante por ser, funcionalmente, una combinación
+entre ``concpu`` y ``split``, con un agregado extra: el incremento notable de
+la competencia por utilizar el recolector entre los múltiples hilos.
+
+Los efectos observados (en la figura :vref:`fig:sol-mcore-1cpu` para
+1 procesador y en la figura :vref:`fig:sol-mcore-4cpu` para 4) confirman esto,
+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 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).
+
+Otro efecto común observado es que cuando el tiempo de pausa es muy pequeño
+(del orden de los milisegundos), el marcado concurrente suele incrementarlo en
+vez de disminuirlo.
+
+``rnddata``
+^^^^^^^^^^^

 En la figura :vref:`fig:sol-rnddata-1cpu` se presentan los resultados para
 ``rnddata`` utilizando 1 procesador. Una vez más estamos ante un caso en el
 cual se observa claramente la mejoría gracias a una modificación en particular
 En la figura :vref:`fig:sol-rnddata-1cpu` se presentan los resultados para
 ``rnddata`` utilizando 1 procesador. Una vez más estamos ante un caso en el
 cual se observa claramente la mejoría gracias a una modificación en particular


@@ -2724,12 +2732,12 @@ pagar si se necesitan tiempos de pausa muy pequeños).
 El aumento en el variación de los tiempos de ejecución al usar marcado preciso
 probablemente se debe a lo siguiente: con marcado conservativo, debe estar
 sobreviviendo a las recolecciones el total de memoria pedida por el programa,
 El aumento en el variación de los tiempos de ejecución al usar marcado preciso
 probablemente se debe a lo siguiente: con marcado conservativo, debe estar
 sobreviviendo a las recolecciones el total de memoria pedida por el programa,

-debido a falsos punteros (por eso no se observa prácticamente variación en el
+debido a *falsos positivos* (por eso no se observa prácticamente variación en el

 tiempo de ejecución y memoria máxima consumida); al marcar con precisión
 tiempo de ejecución y memoria máxima consumida); al marcar con precisión

-parcial, se logra disminuir mucho la cantidad de falsos punteros, pero el
+parcial, se logra disminuir mucho la cantidad de *falsos positivos*, pero el

 *stack* y la memoria estática, se sigue marcado de forma conservativa, por lo
 tanto dependiendo de los valores (aleatorios) generados por la prueba, aumenta
 *stack* y la memoria estática, se sigue marcado de forma conservativa, por lo
 tanto dependiendo de los valores (aleatorios) generados por la prueba, aumenta

-o disminuye la cantidad de falsos punteros, variando así la cantidad de
+o disminuye la cantidad de *falsos positivos*, variando así la cantidad de

 memoria consumida y el tiempo de ejecución.
 
 No se muestran los resultados para más de un procesador por ser demasiado
 memoria consumida y el tiempo de ejecución.
 
 No se muestran los resultados para más de un procesador por ser demasiado


@@ -2745,79 +2753,67 @@ objetos grandes y otra objetos pequeños, pero esta diferencia parece no
 afectar la forma en la que se comportan los cambios introducidos en este
 trabajo.
 
 afectar la forma en la que se comportan los cambios introducidos en este
 trabajo.
 

+.. flt:: fig:sol-bh-1cpu

 
 

-Resultados para pruebas pequeñas
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-A continuación se presentan los resultados obtenidos para las pruebas pequeñas
-(ver :ref:`sol_bench_small`). Se recuerda que si bien este conjunto de pruebas
-se compone de programas reales, que efectúan una tarea útil, están diseñados
-para ejercitar la asignación de memoria y que no son recomendados para evaluar
-el desempeño de recolectores de basura. Sin embargo se las utiliza igual por
-falta de programas más realistas, por lo que hay que tomarlas como un grado de
-suspicacia.
-
-``bh``
-^^^^^^
-.. fig:: fig:sol-bh-1cpu
-
-   Resultados para ``bh`` (utilizando 1 procesador).
+   Resultados para ``bh`` (utilizando 1 procesador)

 
    Resultados para ``bh`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``bh`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-bh-1cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-bh-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-bh-1cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-bh-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-bh-1cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-bh-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-bh-1cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-bh-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-bh-1cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-bh-1cpu.pdf
 

-En la figura :vref:`fig:sol-bh-1cpu` se pueden observar los resultados
-para ``bh`` al utilizar un solo procesador. Ya en una prueba un poco más
-realista se puede observar el efecto positivo del marcado preciso, en especial
-en la cantidad de recolecciones efectuadas (aunque no se traduzca en un menor
-consumo de memoria).
+.. raw:: latex

 
 

-Sin embargo se observa también un efecto nocivo del marcado preciso en el
-consumo de memoria que intuitivamente debería disminuir, pero crece, y de
-forma considerable (unas 3 veces en promedio). La razón de esta particularidad
-es el incremento en el espacio necesario para almacenar objetos debido a que
-el puntero a la información del tipo se guarda al final del bloque (ver
-:ref:`sol_precise`). En el cuadro :vref:`t:sol-prec-mem-bh` se puede observar
-la cantidad de memoria pedida por el programa, la cantidad de memoria
-realmente asignada por el recolector (y la memoria desperdiciada) cuando se
-usa marcado conservativo y preciso. Estos valores fueron tomados usando la
-opción ``malloc_stats_file`` (ver :ref:`sol_stats`).
+   \clearpage

 
 

-.. ftable:: t:sol-prec-mem-bh

 
 

-   Memoria pedida y asignada para ``bh`` según modo de marcado.
+Resultados para pruebas pequeñas
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A continuación se presentan los resultados obtenidos para las pruebas pequeñas
+(ver :ref:`sol_bench_small`). Se recuerda que si bien este conjunto de pruebas
+se compone de programas reales, que efectúan una tarea útil, están diseñados
+para ejercitar la asignación de memoria y que no son recomendados para evaluar
+el desempeño de recolectores de basura. Sin embargo se las utiliza igual por
+falta de programas más realistas, por lo que hay que tomarlas como un grado de
+suspicacia.
+
+``bh``
+^^^^^^
+.. flt:: t:sol-prec-mem-bh
+   :type: table
+
+   Memoria pedida y asignada para ``bh`` según modo de marcado

 
    Memoria pedida y asignada para ``bh`` según modo de marcado conservativo
    o preciso (acumulativo durante toda la vida del programa).
 
    Memoria pedida y asignada para ``bh`` según modo de marcado conservativo
    o preciso (acumulativo durante toda la vida del programa).


@@ -2829,55 +2825,72 @@ opción ``malloc_stats_file`` (ver :ref:`sol_stats`).
    Preciso        302.54         472.26         169.72 (36%)
    ============== ============== ============== =================
 
    Preciso        302.54         472.26         169.72 (36%)
    ============== ============== ============== =================
 

-Más allá de esto, los resultados son muy similares a los obtenidos para
-pruebas sintetizadas que se limitan a ejercitar el recolector (como ``bigarr``
-y ``sbtree``), lo que habla de lo mucho que también lo hace este pequeño
-programa.
-
-No se muestran los resultados para más de un procesador por ser extremadamente
-similares a los obtenidos utilizando solo uno.
-
-``bisort``
-^^^^^^^^^^
-.. fig:: fig:sol-bisort-1cpu
+.. flt:: fig:sol-bisort-1cpu

 
 

-   Resultados para ``bisort`` (utilizando 1 procesador).
+   Resultados para ``bisort`` (utilizando 1 procesador)

 
    Resultados para ``bisort`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``bisort`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-bisort-1cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-bisort-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-bisort-1cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-bisort-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-bisort-1cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-bisort-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-bisort-1cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-bisort-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-bisort-1cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-bisort-1cpu.pdf
 

+En la figura :vref:`fig:sol-bh-1cpu` se pueden observar los resultados
+para ``bh`` al utilizar un solo procesador. Ya en una prueba un poco más
+realista se puede observar el efecto positivo del marcado preciso, en especial
+en la cantidad de recolecciones efectuadas (aunque no se traduzca en un menor
+consumo de memoria).
+
+Sin embargo se observa también un efecto nocivo del marcado preciso en el
+consumo de memoria que intuitivamente debería disminuir, pero crece, y de
+forma considerable (unas 3 veces en promedio). La razón de esta particularidad
+es el incremento en el espacio necesario para almacenar objetos debido a que
+el puntero a la información del tipo se guarda al final del bloque (ver
+:ref:`sol_precise`). En el cuadro :vref:`t:sol-prec-mem-bh` se puede observar
+la cantidad de memoria pedida por el programa, la cantidad de memoria
+realmente asignada por el recolector (y la memoria desperdiciada) cuando se
+usa marcado conservativo y preciso. Estos valores fueron tomados usando la
+opción ``malloc_stats_file`` (ver :ref:`sol_stats`).
+
+Más allá de esto, los resultados son muy similares a los obtenidos para
+pruebas sintetizadas que se limitan a ejercitar el recolector (como ``bigarr``
+y ``sbtree``), lo que habla de lo mucho que también lo hace este pequeño
+programa.
+
+No se muestran los resultados para más de un procesador por ser extremadamente
+similares a los obtenidos utilizando solo uno.
+
+``bisort``
+^^^^^^^^^^

 La figura :vref:`fig:sol-bisort-1cpu` muestra los resultados para ``bisort``
 al utilizar 1 procesador. En este caso el parecido es con los resultados para
 la prueba sintetizada ``split``, con la diferencia que el tiempo de ejecución
 La figura :vref:`fig:sol-bisort-1cpu` muestra los resultados para ``bisort``
 al utilizar 1 procesador. En este caso el parecido es con los resultados para
 la prueba sintetizada ``split``, con la diferencia que el tiempo de ejecución


@@ -2887,194 +2900,198 @@ caché de ``findSize()``).
 
 Otra diferencia notable es la considerable reducción del tiempo de pausa real
 al utilizar *early collection* (más de 3 veces menor en promedio comparado
 
 Otra diferencia notable es la considerable reducción del tiempo de pausa real
 al utilizar *early collection* (más de 3 veces menor en promedio comparado

-a cuando se marca conservativamente, y más de 2 veces menor que cuando se hace
-de forma precisa), lo que indica que la predicción de cuando se va a necesitar
-una recolección es más efectiva que para ``split``.
+a cuando se marca de forma conservativa, y más de 2 veces menor que cuando se
+hace de forma precisa), lo que indica que la predicción de cuando se va
+a necesitar una recolección es más efectiva que para ``split``.

 
 No se muestran los resultados para más de un procesador por ser extremadamente
 similares a los obtenidos utilizando solo uno.
 
 
 No se muestran los resultados para más de un procesador por ser extremadamente
 similares a los obtenidos utilizando solo uno.
 

-``em3d``
-^^^^^^^^
-.. fig:: fig:sol-em3d-1cpu
+.. raw:: latex
+
+   \clearpage

 
 

-   Resultados para ``em3d`` (utilizando 1 procesador).
+.. flt:: fig:sol-em3d-1cpu
+
+   Resultados para ``em3d`` (utilizando 1 procesador)

 
    Resultados para ``em3d`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``em3d`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-em3d-1cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-em3d-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-em3d-1cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-em3d-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-em3d-1cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-em3d-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-em3d-1cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-em3d-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-em3d-1cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-em3d-1cpu.pdf
 

+``em3d``
+^^^^^^^^

 Los resultados para ``em3d`` (figura :vref:`fig:sol-em3d-1cpu`) son
 sorprendentemente similares a los de ``bisort``. La única diferencia es que en
 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
 extremadamente similares a los obtenidos utilizando solo uno.
 
 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
 extremadamente similares a los obtenidos utilizando solo uno.
 

-``tsp``
-^^^^^^^^
-.. fig:: fig:sol-tsp-1cpu
+.. flt:: fig:sol-tsp-1cpu

 
 

-   Resultados para ``tsp`` (utilizando 1 procesador).
+   Resultados para ``tsp`` (utilizando 1 procesador)

 
    Resultados para ``tsp`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``tsp`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-tsp-1cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-tsp-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-tsp-1cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-tsp-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-tsp-1cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-tsp-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-tsp-1cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-tsp-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-tsp-1cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-tsp-1cpu.pdf
 

-Los resultados para ``tsp`` (figura :vref:`fig:sol-tsp-1cpu`) son
-prácticamente idénticos a los de ``bisort``. La única diferencia es que la
-reducción del tiempo de pausa real es un poco menor.
+.. flt:: fig:sol-voronoi-1cpu

 
 

-Esto confirma en cierta medida la poca utilidad de este juego de pruebas para
-medir el rendimiento de un recolector, dado que evidentemente, si bien todas
-resuelven problemas diferentes, realizan todas el mismo tipo de trabajo.
-
-Una vez más no se muestran los resultados para más de un procesador por ser
-extremadamente similares a los obtenidos utilizando solo uno.
-
-``voronoi``
-^^^^^^^^^^^
-.. fig:: fig:sol-voronoi-1cpu
-
-   Resultados para ``voronoi`` (utilizando 1 procesador).
+   Resultados para ``voronoi`` (utilizando 1 procesador)

 
    Resultados para ``voronoi`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``voronoi`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-voronoi-1cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-voronoi-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-voronoi-1cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-voronoi-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-voronoi-1cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-voronoi-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-voronoi-1cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-voronoi-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-voronoi-1cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-voronoi-1cpu.pdf
 

-.. fig:: fig:sol-voronoi-4cpu
+.. flt:: fig:sol-voronoi-4cpu

 
 

-   Resultados para ``voronoi`` (utilizando 4 procesadores).
+   Resultados para ``voronoi`` (utilizando 4 procesadores)

 
    Resultados para ``voronoi`` (utilizando 4 procesadores). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``voronoi`` (utilizando 4 procesadores). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-voronoi-4cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-voronoi-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-voronoi-4cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-voronoi-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-voronoi-4cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-voronoi-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-voronoi-4cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-voronoi-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-voronoi-4cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-voronoi-4cpu.pdf
 

+``tsp``
+^^^^^^^^
+Los resultados para ``tsp`` (figura :vref:`fig:sol-tsp-1cpu`) son
+prácticamente idénticos a los de ``bisort``. La única diferencia es que la
+reducción del tiempo de pausa real es un poco menor.
+
+Esto confirma en cierta medida la poca utilidad de este juego de pruebas para
+medir el rendimiento de un recolector, dado que evidentemente, si bien todas
+resuelven problemas diferentes, realizan todas el mismo tipo de trabajo.
+
+Una vez más no se muestran los resultados para más de un procesador por ser
+extremadamente similares a los obtenidos utilizando solo uno.
+
+``voronoi``
+^^^^^^^^^^^

 En la figura :vref:`fig:sol-voronoi-1cpu` se presentan los resultados para
 ``voronoi``, probablemente la prueba más interesante de este conjunto de
 pruebas pequeñas.
 En la figura :vref:`fig:sol-voronoi-1cpu` se presentan los resultados para
 ``voronoi``, probablemente la prueba más interesante de este conjunto de
 pruebas pequeñas.


@@ -3086,10 +3103,10 @@ este caso no parece provenir toda la ganancia solo de ese cambio, dado que
 para TBGC se ve una variación entre los resultados muy grande que desaparece
 al cambiar a CDGC, esto no puede ser explicado por esa optimización. En
 general la disminución de la variación de los resultados hemos visto que está
 para TBGC se ve una variación entre los resultados muy grande que desaparece
 al cambiar a CDGC, esto no puede ser explicado por esa optimización. En
 general la disminución de la variación de los resultados hemos visto que está

-asociada al incremento en la precisión en el marcado, dado que los falsos
-punteros ponen una cuota de aleatoriedad importante. Pero este tampoco parece
-ser el caso, ya que no se observan cambios apreciables al pasar a usar marcado
-preciso.
+asociada al incremento en la precisión en el marcado, dado que los *falsos
+positivos* ponen una cuota de aleatoriedad importante. Pero este tampoco
+parece ser el caso, ya que no se observan cambios apreciables al pasar a usar
+marcado preciso.

 
 Lo que se observa en esta oportunidad es un caso patológico de un mal factor
 de ocupación del *heap* (ver :ref:`sol_ocup`). Lo que muy probablemente está
 
 Lo que se observa en esta oportunidad es un caso patológico de un mal factor
 de ocupación del *heap* (ver :ref:`sol_ocup`). Lo que muy probablemente está


@@ -3109,104 +3126,104 @@ al usar 4 (ver figura :vref:`fig:sol-voronoi-4cpu` disminuye levemente (además
 de otros cambios en el nivel de variación, pero en general las medias no
 cambian).
 
 de otros cambios en el nivel de variación, pero en general las medias no
 cambian).
 

-

 Resultados para pruebas reales
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Resultados para pruebas reales
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

-A continuación se presentan los resultados obtenidos para las pruebas reales
-(ver :ref:`sol_bench_real`). Recordamos que solo se pudo halla un programa que
-pueda ser utilizado a este fin, Dil_, y que el objetivo principal de este
-trabajo se centra alrededor de obtener resultados positivos para este
-programa, por lo que a pesar de ser una única prueba, se le presta particular
-atención.
-
-``dil``
-^^^^^^^
-.. fig:: fig:sol-dil-1cpu
+.. flt:: fig:sol-dil-1cpu

 
 

-   Resultados para ``dil`` (utilizando 1 procesador).
+   Resultados para ``dil`` (utilizando 1 procesador)

 
    Resultados para ``dil`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``dil`` (utilizando 1 procesador). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-dil-1cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-dil-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-dil-1cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-dil-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-dil-1cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-dil-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-dil-1cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-dil-1cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-dil-1cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-dil-1cpu.pdf
 

-.. fig:: fig:sol-dil-4cpu
+A continuación se presentan los resultados obtenidos para las pruebas reales
+(ver :ref:`sol_bench_real`). Recordamos que solo se pudo halla un programa que
+pueda ser utilizado a este fin, Dil_, y que el objetivo principal de este
+trabajo se centra alrededor de obtener resultados positivos para este
+programa, por lo que a pesar de ser una única prueba, se le presta particular
+atención.

 
 

-   Resultados para ``dil`` (utilizando 4 procesadores).
+``dil``
+^^^^^^^
+En la figura :vref:`fig:sol-dil-1cpu` se presentan los resultados para
+``dil`` al utilizar un procesador. Una vez más vemos una mejoría inmediata del
+tiempo total de ejecución al pasar de TBGC a CDGC, y una vez más se debe
+principalmente al mal factor de ocupación del *heap* de TBGC, dado que
+utilizando CDGC con la opción ``min_free=0`` se obtiene una media del orden de
+los 80 segundos, bastante más alta que el tiempo obtenido para TBGC.
+
+.. flt:: fig:sol-dil-4cpu
+   :placement: t
+
+   Resultados para ``dil`` (utilizando 4 procesadores)

 
    Resultados para ``dil`` (utilizando 4 procesadores). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 
 
    Resultados para ``dil`` (utilizando 4 procesadores). Se presenta el
    mínimos (en negro), la media centrada entre dos desvíos estándar (en gris),
    y el máximo (en blanco) calculados sobre 50 corridas (para tiempo de
    ejecución) o 20 corridas (para el resto).
 

-   .. subfig::
+   .. subflt::

 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-dil-4cpu.pdf
 
 
       Tiempo de ejecución (seg)
 
       .. image:: plots/time-dil-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-dil-4cpu.pdf
 
 
       Cantidad de recolecciones
 
       .. image:: plots/ncol-dil-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-dil-4cpu.pdf
 
 
       Uso máximo de memoria (MiB)
 
       .. image:: plots/mem-dil-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-dil-4cpu.pdf
 
 
       *Stop-the-world* máximo (seg)
 
       .. image:: plots/stw-dil-4cpu.pdf
 

-   .. subfig::
+   .. subflt::

 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-dil-4cpu.pdf
 
 
       Pausa real máxima (seg)
 
       .. image:: plots/pause-dil-4cpu.pdf
 

-En la figura :vref:`fig:sol-dil-1cpu` se presentan los resultados para
-``dil`` al utilizar un procesador. Una vez más vemos una mejoría inmediata del
-tiempo total de ejecución al pasar de TBGC a CDGC, y una vez más se debe
-principalmente al mal factor de ocupación del *heap* de TBGC, dado que
-utilizando CDGC con la opción ``min_free=0`` se obtiene una media del orden de
-los 80 segundos, bastante más alta que el tiempo obtenido para TBGC.
-

 Sin embargo se observa un pequeño incremento del tiempo de ejecución al
 introducir marcado preciso, y un incremento bastante más importante (de
 alrededor del 30%) en el consumo máximo de memoria. Nuevamente, como pasa con
 Sin embargo se observa un pequeño incremento del tiempo de ejecución al
 introducir marcado preciso, y un incremento bastante más importante (de
 alrededor del 30%) en el consumo máximo de memoria. Nuevamente, como pasa con


@@ -3216,14 +3233,11 @@ información del tipo se guarda al final del bloque (ver :ref:`sol_precise`).
 En el cuadro :vref:`t:sol-prec-mem-dil` se puede observar la diferencia de
 memoria desperdiciada entre el modo conservativo y preciso.
 
 En el cuadro :vref:`t:sol-prec-mem-dil` se puede observar la diferencia de
 memoria desperdiciada entre el modo conservativo y preciso.
 

-El pequeño incremento en el tiempo total de ejecución podría estar dado por la
-mayor probabilidad de tener *falsos punteros* debido al incremento del tamaño
-del *heap*; se recuerda que el *stack* y memoria estática se siguen marcado de
-forma conservativa, incluso en modo preciso.
-
-.. ftable:: t:sol-prec-mem-dil
+.. flt:: t:sol-prec-mem-dil
+   :type: table
+   :placement: b

 
 

-   Memoria pedida y asignada para ``dil`` según modo de marcado.
+   Memoria pedida y asignada para ``dil`` según modo de marcado

 
    Memoria pedida y asignada para ``dil`` según modo de marcado conservativo
    o preciso (acumulativo durante toda la vida del programa).
 
    Memoria pedida y asignada para ``dil`` según modo de marcado conservativo
    o preciso (acumulativo durante toda la vida del programa).


@@ -3235,12 +3249,17 @@ forma conservativa, incluso en modo preciso.
    Preciso        307.48         460.24         152.76 (33%)
    ============== ============== ============== =================
 
    Preciso        307.48         460.24         152.76 (33%)
    ============== ============== ============== =================
 

+El pequeño incremento en el tiempo total de ejecución podría estar dado por la
+mayor probabilidad de tener *falsos positivos* debido al incremento del tamaño
+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
 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
 (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


@@ -3267,15 +3286,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
 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
 
 
 .. include:: links.rst