]> git.llucax.com Git - z.facultad/75.00/informe.git/blobdiff - source/solucion.rst
Abreviar autores en referencia [BLA06]
[z.facultad/75.00/informe.git] / source / solucion.rst
index 2c3657885eecad70177c122a9b849ed53789124f..c714895220038bd8c6d1aaf9cb53244281fe19f1 100644 (file)
@@ -1,6 +1,6 @@
 
 .. Acá va lo que decidí hacer en base al análisis anterior y sus razones.
 
 .. Acá va lo que decidí hacer en base al análisis anterior y sus razones.
-   ESTADO: EMPEZADO
+   ESTADO: TERMINADO
 
 
 .. _solucion:
 
 
 .. _solucion:
@@ -8,13 +8,13 @@
 Solución adoptada
 ============================================================================
 
 Solución adoptada
 ============================================================================
 
-Como hemos visto en :ref:`dgc_bad`, la mejora del recolector de basura puede
-ser abordada desde múltiples flancos. Por lo tanto, para reducir la cantidad
-de posibilidades hay que tener en cuenta uno de los principales objetivos de
-este trabajo: encontrar una solución que tenga una buena probabilidad de ser
-adoptada por el lenguaje, o alguno de sus compiladores al menos. Para asegurar
-esto, la solución debe tener un alto grado de aceptación en la comunidad, lo
-que implica algunos puntos claves:
+Como hemos visto en :ref:`dgc`, la mejora del recolector de basura puede ser
+abordada desde múltiples flancos, con varias alternativas viables. Por lo
+tanto, para reducir la cantidad de posibilidades hay que tener en cuenta uno
+de los principales objetivos de este trabajo: encontrar una solución que tenga
+una buena probabilidad de ser adoptada por el lenguaje, o alguno de sus
+compiladores al menos. Para asegurar esto, la solución debe tener un alto
+grado de aceptación en la comunidad, lo que implica algunos puntos claves:
 
 * La eficiencia general de la solución no debe ser notablemente peor, en
   ningún aspecto, que la implementación actual.
 
 * La eficiencia general de la solución no debe ser notablemente peor, en
   ningún aspecto, que la implementación actual.
@@ -38,6 +38,8 @@ se intenta abordar los demás problemas planteados siempre que sea posible
 hacerlo sin alejarse demasiado del objetivo principal.
 
 
 hacerlo sin alejarse demasiado del objetivo principal.
 
 
+.. highlight:: d
+
 .. _sol_bench:
 
 Banco de pruebas
 .. _sol_bench:
 
 Banco de pruebas
@@ -141,8 +143,8 @@ El código fuente del programa es el siguiente::
             indi[] = testPop1.individuals ~ testPop2.individuals;
          }
          version (everythingOk) {
             indi[] = testPop1.individuals ~ testPop2.individuals;
          }
          version (everythingOk) {
-            indi[0..N1] = testPop1.individuals;
-            indi[N1..N2] = testPop2.individuals;
+            indi[0 .. N1] = testPop1.individuals;
+            indi[N1 .. N2] = testPop2.individuals;
          }
       }
       return 0;
          }
       }
       return 0;
@@ -279,8 +281,8 @@ Este programa trivial lee un archivo de texto y genera un arreglo de cadenas
 de texto resultantes de partir el texto en palabras. Fue escrito por Leonardo
 Maffi y también hallado__ en el grupo de noticias de D_. Su objetivo era
 mostrar lo ineficiente que puede ser concatenar datos a un mismo arreglo
 de texto resultantes de partir el texto en palabras. Fue escrito por Leonardo
 Maffi y también hallado__ en el grupo de noticias de D_. Su objetivo era
 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 apalear el problema de forma razonablemente efectiva.
+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::
 
 
 El código es el siguiente::
 
@@ -302,7 +304,6 @@ El código es el siguiente::
    }
 
 __ http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=67673
    }
 
 __ http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=67673
-__ http://d.puremagic.com/issues/show_bug.cgi?id=1923
 
 
 ``rnddata``
 
 
 ``rnddata``
@@ -310,7 +311,7 @@ __ http://d.puremagic.com/issues/show_bug.cgi?id=1923
 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
@@ -563,6 +564,8 @@ ser útiles para encontrar problemas muy particulares, está es la que da una
 lectura más cercana a la realidad del uso de un recolector.
 
 
 lectura más cercana a la realidad del uso de un recolector.
 
 
+.. highlight:: pcode
+
 .. _sol_mod:
 
 Modificaciones propuestas
 .. _sol_mod:
 
 Modificaciones propuestas
@@ -799,7 +802,9 @@ Caché de ``Pool.findSize()``
 Se crea un caché de tamaño de bloque para el método ``findSize()`` de un
 *pool*. Esto acelera considerablemente las operaciones que necesitan pedir el
 tamaño de un bloque reiteradamente, por ejemplo, al añadir nuevos elementos
 Se crea un caché de tamaño de bloque para el método ``findSize()`` de un
 *pool*. Esto acelera considerablemente las operaciones que necesitan pedir el
 tamaño de un bloque reiteradamente, por ejemplo, al añadir nuevos elementos
-a un arreglo dinámico.
+a un arreglo dinámico. En esencia es una extensión a una de las optimizaciones
+propuestas por Vladimir Panteleev [PAN09]_, que propone un caché global para
+todo el recolector en vez de uno por *pool*.
 
 Esta mejora tampoco afecta a la corrección del algoritmo, ya que nuevamente no
 afecta su comportamiento a nivel lógico, solo cambia detalles en la
 
 Esta mejora tampoco afecta a la corrección del algoritmo, ya que nuevamente no
 afecta su comportamiento a nivel lógico, solo cambia detalles en la
@@ -882,7 +887,7 @@ 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
 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.
+recursivo, es impracticable por resultar 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.
@@ -930,10 +935,10 @@ 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``.
 
 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
@@ -1083,18 +1088,14 @@ recolector.
 Marcado preciso
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Marcado preciso
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-En paralelo con este trabajo, David Simcha comienza a explorar la posibilidad
-de agregar precisión parcial al recolector, generando información sobre la
-ubicación de los punteros para cada tipo [DBZ3463]_. Su trabajo se limita
-a una implementación a nivel biblioteca de usuario y sobre `D 2.0`_.
-Desafortunadamente su trabajo pasa desapercibido por un buen tiempo.
+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).
 
 
-Luego Vincent Lang (mejor conocido como *wm4* en la comunidad de D_), retoma
-este trabajo, pero modificando el compilador DMD_ y trabajando con `D 1.0`_
-y Tango_, al igual que este trabajo. Dado el objetivo y entorno común, se abre
-la posibilidad de adaptar los cambios de Vincent Lang a este trabajo,
-utilizando una versión modificada de DMD_ (dado que los cambios aún no son
-integrados al compilador oficial).
+.. TODO: Apéndice con parches a DMD y Tango?
 
 Información de tipos provista por el compilador
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Información de tipos provista por el compilador
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -1104,9 +1105,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
@@ -1136,7 +1138,9 @@ a continuación.
 
 Los conjuntos de bits guardan la información sobre la primera palabra en el
 bit menos significativo. Dada la complejidad de la representación, se ilustra
 
 Los conjuntos de bits guardan la información sobre la primera palabra en el
 bit menos significativo. Dada la complejidad de la representación, se ilustra
-con un ejemplo. Dada la estructura::
+con un ejemplo. Dada la estructura:
+
+.. code-block:: d
 
    union U {
       ubyte ub;
 
    union U {
       ubyte ub;
@@ -1166,9 +1170,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:
@@ -1226,10 +1230,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
@@ -1380,11 +1384,12 @@ que la memoria sea compartida entre los procesos de forma explícita.
 
 Esto, sin embargo, no significa que la memoria física sea realmente duplicada;
 en general todos los sistemas operativos modernos (como Linux_) utilizan una
 
 Esto, sin embargo, no significa que la memoria física sea realmente duplicada;
 en general todos los sistemas operativos modernos (como Linux_) utilizan una
-técnica llamada *copy-on-write* (*copiar-al-escribir* en castellano) que
-retrasa la copia de memoria hasta que alguno de los dos procesos escribe en un
-segmento. Recién en ese momento el sistema operativo realiza la copia de **ese
-segmento solamente**. Es por esto que la operación puede ser muy eficiente,
-y la copia de memoria es proporcional a la cantidad de cambios que hayan.
+técnica llamada *COW* (de *copy-on-write* en inglés, *copiar-al-escribir* en
+castellano) que retrasa la copia de memoria hasta que alguno de los dos
+procesos escribe en un segmento. Recién en ese momento el sistema operativo
+realiza la copia de **ese segmento solamente**. Es por esto que la operación
+puede ser muy eficiente, y la copia de memoria es proporcional a la cantidad
+de cambios que hayan.
 
 :manpage:`fork(2)` tiene otra propiedad importante de mencionar: detiene todos
 los hilos de ejecución en el proceso hijo. Es decir, el proceso hijo se crear
 
 :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
@@ -1583,7 +1588,7 @@ empezar la fase de marcado no sean barridas por tener ese bit activo::
             pages = assign_pages(pool, number_of_pages)
       pages[0].block.free = true                         // Agregado
       pages[0].block_size = PAGE
             pages = assign_pages(pool, number_of_pages)
       pages[0].block.free = true                         // Agregado
       pages[0].block_size = PAGE
-      foreach page in pages[1..end]
+      foreach page in pages[1 .. end]
          page.block_size = CONTINUATION
       return pages[0]
 
          page.block_size = CONTINUATION
       return pages[0]
 
@@ -1908,8 +1913,6 @@ que se especifique lo contrario), que se detallan a continuación.
    ``$dst_dir`` es el directorio donde almacenar los archivos generados
    y ``$tango_files`` es la lista de archivos fuente de Tango_.
 
    ``$dst_dir`` es el directorio donde almacenar los archivos generados
    y ``$tango_files`` es la lista de archivos fuente de Tango_.
 
-.. highlight:: d
-
 El resto de los programas se ejecutan sin parámetros (ver :ref:`sol_bench`
 para una descripción detallada sobre cada uno).
 
 El resto de los programas se ejecutan sin parámetros (ver :ref:`sol_bench`
 para una descripción detallada sobre cada uno).
 
@@ -1965,8 +1968,6 @@ todo
 
       conservative=0:fork=1:early_collect=1:eager_alloc=1
 
 
       conservative=0:fork=1:early_collect=1:eager_alloc=1
 
-.. highlight:: d
-
 Métricas utilizadas
 ^^^^^^^^^^^^^^^^^^^
 Para analizar los resultados se utilizan varias métricas. Las más importantes
 Métricas utilizadas
 ^^^^^^^^^^^^^^^^^^^
 Para analizar los resultados se utilizan varias métricas. Las más importantes
@@ -2082,9 +2083,10 @@ 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.
 
 direcciones bajas. La opción ``-R`` solamente desactiva la componente azarosa
 al momento de asignar direcciones.
 
-.. ftable:: t:sol-setarch
+.. flt:: t:sol-setarch
+   :type: table
 
 
-   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 +2094,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 +2116,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.
 
@@ -2139,7 +2141,7 @@ 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
 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,
+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
 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
@@ -2153,67 +2155,6 @@ 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.
 
 analizan los resultados de un gran número de corridas observando
 principalmente su mínima, media, máxima y desvío estándar.
 
-.. Tamaño del ejecutable (XXX: SEGUN LAS PRUEBAS NO FUCKING CAMBIA!!!)
-   El tamaño del ejecutable es un factor importante. Cuanto más grande es el
-   ejecutable, más parecieran variar los resultados. Por ejemplo se observa un
-   incremento de la estabilidad de los resultados al eliminar toda información
-   de depuración (*debug*) del ejecutable, utilizando el comando
-   :manpage:`strip(1)` (*stripped*). En el cuadro :vref:`t:sol-exesize-tbgc`
-   se puede ver la reducción del tamaño del ejecutable para TBGC cuando se
-   elimina la información de depuración (4.25 veces más chico en promedio),
-   mientas que en el cuadro :vref:`t:sol-exesize-cdgc` se puede ver CDGC (4.6
-   veces más chico en promedio).
-   .. ftable:: t:sol-exesize-tbgc
-      Reducción del tamaño del ejecutable para TBGC.
-      ======== ======== ======== ==============
-      Nombre   Debug    Stripped Debug/Stripped
-      ======== ======== ======== ==============
-      bh       586517   138060   4.248
-      bigarr   547687   192004   2.852
-      bisort   485857   115164   4.219
-      conalloc 616613   149848   4.115
-      concpu   616575   149848   4.115
-      dil      7293277  1859208  3.923
-      em3d     505019   116324   4.341
-      mcore    461767   105748   4.367
-      rnddata  2832935  1492588  1.898
-      sbtree   526402   129860   4.054
-      split    589353   144308   4.084
-      tree     462009   105844   4.365
-      tsp      544901   128412   4.243
-      voronoi  601259   141112   4.261
-      ======== ======== ======== ==============
-   .. ftable:: t:sol-exesize-cdgc
-      Reducción del tamaño del ejecutable para CDGC.
-      ========  ======== ======== ===============
-      Nombre    Debug    Stripped Debug/Stripped
-      ========  ======== ======== ===============
-      bh        736115   159884   4.604
-      bigarr    697406   213832   3.261
-      bisort    635537   136988   4.639
-      conalloc  766328   171676   4.464
-      concpu    766294   171676   4.464
-      dil       7442657  1881028  3.957
-      em3d      658827   142248   4.632
-      mcore     611486   127576   4.793
-      rnddata   2986736  1518512  1.967
-      sbtree    680217   155784   4.366
-      split     739072   166136   4.449
-      tree      611728   127672   4.791
-      tsp       694581   150236   4.623
-      voronoi   750847   162936   4.608
-      ========  ======== ======== ===============
-   TODO: Mostrar tiempos de corridas.
-
-
-.. Resultados generales
-   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. Primero se presenta una visión global de los resultados, utilizando las
-   métricas más importantes. Para generar los gráficos se utilizan los valores
-   máximos (en blanco), mínimos (en negro), media y desvío estándar (en gris)
-   calculados en base a, como mínimo, 20 corridas (para algunos casos se hacen
-   hasta 50 corridas).
 
 
 Resultados para pruebas sintizadas
 
 
 Resultados para pruebas sintizadas
@@ -2226,543 +2167,543 @@ 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.
 
 programa real, por lo que los resultados deben ser analizados teniendo esto
 presente.
 
-``bigarr``
-^^^^^^^^^^
-.. fig:: fig:sol-bigarr-1cpu
+.. flt:: 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
+.. flt:: fig:sol-bigarr-4cpu
 
 
-   Resultados para ``bigarr`` (utilizando 4 procesadores).
+   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
-más veloz pidiendo memoria que recolectándola, por lo que crece mucho el
-consumo de memoria. Como consecuencia la fase de barrido (que no corre en
-paralelo al *mutator* como la fase de marcado) empieza a ser predominante en
-el tiempo de pausa por ser tan grande la cantidad de memoria a barrer. Este
-efecto se ve tanto al usar 1 como 4 procesadores, aunque el efecto es mucho
-más nocivo al usar 1 debido a la alta variabilidad que impone la competencia
-entre el *mutator* y recolector al correr de forma concurrente.
-
-Sin embargo, el tiempo de *stop-the-world* es siempre considerablemente más
-pequeño al utilizar marcado concurrente en CDGC, incluso cuando se utiliza
-*eager allocation*, aunque en este caso aumenta un poco, también debido al
-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`).
-
-``concpu``
-^^^^^^^^^^
-.. fig:: fig:sol-concpu-1cpu
+.. flt:: fig:sol-concpu-1cpu
 
 
-   Resultados para ``concpu`` (utilizando 1 procesador).
+   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
 
-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.
-
-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
-magnificado), pero sorprendentemente el tiempo total de pausa se dispara,
-además con una variabilidad sorprendente, cuando se usa marcado concurrente
-(pero no *eager allocation*). Una posible explicación podría ser que al
-realizarse el *fork*, el sistema operativo muy probablemente entregue el
-control del único procesador disponible al resto de los hilos que compiten por
-él, por lo que queda mucho tiempo pausado en esa operación aunque realmente no
-esté haciendo trabajo alguno (simplemente no tiene tiempo de procesador para
-correr). Este efecto se cancela al usar *eager allocation* dado que el
-*mutator* nunca se bloquea esperando que el proceso de marcado finalice.
-
-Además se observa una caída importante en la cantidad de recolecciones al
-utilizar marcado concurrente. Esto probablemente se deba a que solo un hilo
-pide memoria (y por lo tanto dispara recolecciones), mientras los demás hilos
-también estén corriendo. Al pausarse todos los hilos por menos tiempo, el
-trabajo se hace más rápido (lo que explica la disminución del tiempo total de
-ejecución) y son necesarias menos recolecciones, por terminar más rápido
-también el hilo que las dispara.
-
-En la :vref:`fig:sol-concpu-4cpu` se pueden ver los resultados al utilizar
-4 procesadores, donde el panorama cambia sustancialmente. El efecto mencionado
-en el párrafo anterior no se observa más (pues el sistema operativo tiene más
-procesadores para asignar a los hilos) pero todos los resultados se vuelven
-más variables. Los tiempos de *stop-the-world* y pausa real (salvo por lo
-recién mencionado) crecen notablemente, al igual que su variación. No se
-encuentra una razón evidente para esto; podría ser un error en la medición
-dado que al utilizar todos los procesadores disponibles del *hardware*,
-cualquier otro proceso que compita por tiempo de procesador puede afectarla
-más fácilmente.
-
-El tiempo total de ejecución crece considerablemente, como se espera, dado que
-el programa aprovecha los múltiples hilos que pueden correr en paralelo en
-procesadores diferentes.
-
-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.
-
-``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).
-
-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``.
+.. flt:: fig:sol-split-1cpu
 
 
-``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
 
-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
-observar con claridad como, para cualquier configuración de CDGC, hay una
-caída notable en el tiempo total de ejecución. Sin embargo, a excepción de
-cuando se utiliza *eager allocation*, la cantidad de recolecciones y memoria
-usada permanece igual.
-
-La utilización de *eager allocation* mejora (aunque de forma apenas
-apreciable) el tiempo de ejecución, la cantidad de recolecciones baja a un
-tercio y el tiempo de pausa real cae dramáticamente. Al usar marcado
-concurrente ya se observa una caída determinante en el tiempo de
-*stop-the-world*. Todo esto sin verse afectado el uso máximo de memoria,
-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.
-
-``mcore``
-^^^^^^^^^
-.. fig:: fig:sol-mcore-1cpu
+.. flt:: fig:sol-mcore-1cpu
 
 
-   Resultados para ``mcore`` (utilizando 1 procesador).
+   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).
-
-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
+.. flt:: 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
 
+``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).
+
+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
+más veloz pidiendo memoria que recolectándola, por lo que crece mucho el
+consumo de memoria. Como consecuencia la fase de barrido (que no corre en
+paralelo al *mutator* como la fase de marcado) empieza a ser predominante en
+el tiempo de pausa por ser tan grande la cantidad de memoria a barrer. Este
+efecto se ve tanto al usar 1 como 4 procesadores, aunque el efecto es mucho
+más nocivo al usar 1 debido a la alta variabilidad que impone la competencia
+entre el *mutator* y recolector al correr de forma concurrente.
+
+Sin embargo, el tiempo de *stop-the-world* es siempre considerablemente más
+pequeño al utilizar marcado concurrente en CDGC, incluso cuando se utiliza
+*eager allocation*, aunque en este caso aumenta un poco, también debido al
+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`).
+
+``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
+mientras no se utilice *eager allocation* pero aumenta al utilizarlo.
+
+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
+magnificado), pero sorprendentemente el tiempo total de pausa se dispara,
+además con una variabilidad sorprendente, cuando se usa marcado concurrente
+(pero no *eager allocation*). Una posible explicación podría ser que al
+realizarse el *fork*, el sistema operativo muy probablemente entregue el
+control del único procesador disponible al resto de los hilos que compiten por
+él, por lo que queda mucho tiempo pausado en esa operación aunque realmente no
+esté haciendo trabajo alguno (simplemente no tiene tiempo de procesador para
+correr). Este efecto se cancela al usar *eager allocation* dado que el
+*mutator* nunca se bloquea esperando que el proceso de marcado finalice.
+
+Además se observa una caída importante en la cantidad de recolecciones al
+utilizar marcado concurrente. Esto probablemente se deba a que solo un hilo
+pide memoria (y por lo tanto dispara recolecciones), mientras los demás hilos
+también estén corriendo. Al pausarse todos los hilos por menos tiempo, el
+trabajo se hace más rápido (lo que explica la disminución del tiempo total de
+ejecución) y son necesarias menos recolecciones, por terminar más rápido
+también el hilo que las dispara.
+
+En la :vref:`fig:sol-concpu-4cpu` se pueden ver los resultados al utilizar
+4 procesadores, donde el panorama cambia sustancialmente. El efecto mencionado
+en el párrafo anterior no se observa más (pues el sistema operativo tiene más
+procesadores para asignar a los hilos) pero todos los resultados se vuelven
+más variables. Los tiempos de *stop-the-world* y pausa real (salvo por lo
+recién mencionado) crecen notablemente, al igual que su variación. No se
+encuentra una razón evidente para esto; podría ser un error en la medición
+dado que al utilizar todos los procesadores disponibles del *hardware*,
+cualquier otro proceso que compita por tiempo de procesador puede afectarla
+más fácilmente.
+
+El tiempo total de ejecución crece considerablemente, como se espera, dado que
+el programa aprovecha los múltiples hilos que pueden correr en paralelo en
+procesadores diferentes.
+
+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.
+
+``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
+observar con claridad como, para cualquier configuración de CDGC, hay una
+caída notable en el tiempo total de ejecución. Sin embargo, a excepción de
+cuando se utiliza *eager allocation*, la cantidad de recolecciones y memoria
+usada permanece igual.
+
+La utilización de *eager allocation* mejora (aunque de forma apenas
+apreciable) el tiempo de ejecución, la cantidad de recolecciones baja a un
+tercio y el tiempo de pausa real cae dramáticamente. Al usar marcado
+concurrente ya se observa una caída determinante en el tiempo de
+*stop-the-world*. Todo esto sin verse afectado el uso máximo de memoria,
+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.
+
+``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 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).
+
+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
@@ -2785,12 +2726,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
@@ -2810,75 +2751,59 @@ trabajo.
 Resultados para pruebas pequeñas
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 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.
+.. flt:: fig:sol-bh-1cpu
 
 
-``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).
-
-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`).
+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.
 
 
-.. ftable:: t:sol-prec-mem-bh
+``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
 
    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).
@@ -2890,252 +2815,269 @@ 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.
+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).
 
 
-``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
 
-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
-total prácticamente no varía entre TBGC y CDGC, ni entre las diferentes
-configuraciones del último (evidentemente en este caso no se aprovecha el
-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
-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``.
-
-No se muestran los resultados para más de un procesador por ser extremadamente
-similares a los obtenidos utilizando solo uno.
+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`).
 
 
-``em3d``
-^^^^^^^^
-.. fig:: fig:sol-em3d-1cpu
+.. flt:: fig:sol-em3d-1cpu
 
 
-   Resultados para ``em3d`` (utilizando 1 procesador).
+   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
 
-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
-ayudar; por el contrario, aumentan levemente el tiempo de pausa real.
+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.
 
 
-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.
+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
+``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
+total prácticamente no varía entre TBGC y CDGC, ni entre las diferentes
+configuraciones del último (evidentemente en este caso no se aprovecha el
+caché de ``findSize()``).
+
+.. 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.
+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 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``.
 
 
-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.
+No se muestran los resultados para más de un procesador por ser extremadamente
+similares a los obtenidos utilizando solo uno.
 
 
-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.
+``em3d``
+^^^^^^^^
+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
+ayudar; por el contrario, aumentan levemente el tiempo de pausa real.
 
 
-``voronoi``
-^^^^^^^^^^^
-.. fig:: fig:sol-voronoi-1cpu
+.. flt:: 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
 
+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``
+^^^^^^^^
+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.
@@ -3147,10 +3089,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á
@@ -3170,104 +3112,103 @@ 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.
+.. flt:: fig:sol-dil-1cpu
 
 
-``dil``
-^^^^^^^
-.. fig:: 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
+
+   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
@@ -3277,14 +3218,10 @@ 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
 
 
-   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).
@@ -3296,6 +3233,11 @@ 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
 (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
 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