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
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;
int main(char[][] args)
{
-
Population testPop1 = new Population;
Population testPop2 = new Population;
Individual[N2] indi;
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
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;
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``
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;
__ 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;
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
__ 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;
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
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/
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:
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
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
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
número, se crea un *pool* con ese tamaño en MiB. Si, en cambio, se
especifica una cadena del tipo ``3x1``, el primer número indica la cantidad
de *pools* y el segundo el tamaño en MiB de cada uno (3 *pools* de 1MiB en
- este caso). Ver :ref:`sol_pre_alloc` para más detalles sobre la utilidad de
- esta opción.
+ este caso). Ver :ref:`sol_pre_alloc` más adelante para más detalles sobre
+ la utilidad de esta opción.
``min_free``
- El valor de esta opción indica el porcentaje mínimo porcentaje del *heap*
- que debe quedar libre luego de una recolección. Siendo un porcentaje, solo
- se aceptan valores entre 0 y 100, siendo su valor por omisión 5. Ver
- :ref:`sol_ocup` para más detalles sobre su propósito.
+ El valor de esta opción indica el porcentaje mínimo del *heap* que debe
+ quedar libre luego de una recolección. Siendo un porcentaje, solo se
+ aceptan valores entre 0 y 100, siendo su valor por omisión 5. Ver
+ :ref:`sol_ocup` más adelante para más detalles sobre su propósito.
``malloc_stats_file``
Esta opción sirve para especificar un archivo en el cual escribir un
reporte de todas la operaciones de pedido de memoria realizadas por el
- programa (durante su tiempo de vida). Ver :ref:`sol_stats` para más
- detalles sobre la información provista y el formato del reporte.
+ programa (durante su tiempo de vida). Ver :ref:`sol_stats` más adelante
+ para más detalles sobre la información provista y el formato del reporte.
``collect_stats_file``
Esta opción sirve para especificar un archivo en el cual escribir un
reporte de todas las recolecciones hechas durante el tiempo de vida del
- programa. Ver :ref:`sol_stats` para más detalles sobre la información
- provista y el formato del reporte.
+ programa. Ver :ref:`sol_stats` más adelante para más detalles sobre la
+ información provista y el formato del reporte.
``conservative``
Esta opción booleana permite desactivar el escaneo preciso del *heap*,
forzando al recolector a ser completamente conservativo (excepto por los
bloques con el atributo ``NO_SCAN`` que siguen sin ser escaneados). Ver
- :ref:`sol_precise` para más detalles sobre la existencia de esta opción.
+ :ref:`sol_precise` más adelante para más detalles sobre la existencia de esta opción.
``fork``
Esta opción booleana (activada por omisión) permite seleccionar si el
recolector debe correr la fase de marcado en paralelo o no (es decir, si el
recolector corre de forma concurrente con el *mutator*). Para más detalles
- ver :ref:`sol_fork`.
+ ver :ref:`sol_fork` más adelante.
``eager_alloc``
Esta opción booleana (activada por omisión), sólo puede estar activa si
- ``fork`` también está activa y sirve para indicar al recolector que reserve
- un nuevo *pool* de memoria cuando una petición no puede ser satisfecha,
- justo antes de lanzar la recolección concurrente. Ver
- :ref:`sol_eager_alloc` para más detalles sobre el propósito de esta opción.
+ ``fork`` también lo está y sirve para indicar al recolector que reserve un
+ nuevo *pool* de memoria cuando una petición no puede ser satisfecha, justo
+ antes de lanzar la recolección concurrente. Ver :ref:`sol_eager_alloc` más
+ adelante para más detalles sobre el propósito de esta opción.
``early_collect``
Esta opción booleana (desactivada por omisión), también sólo puede estar
activa si ``fork`` está activa y sirve para indicar al recolector que lance
una recolección (concurrente) antes de que la memoria libre se termine (la
recolección temprana será disparada cuando el porcentaje de memoria libre
- sea menor a ``min_free``). Ver :ref:`sol_early_collect` para más detalles
- sobre el propósito de esta opción.
+ sea menor a ``min_free``). Ver :ref:`sol_early_collect` más adelante para
+ más detalles sobre el propósito de esta opción.
Cualquier opción o valor no reconocido es ignorado por el recolector. Se
utilizan los valores por omisión de las opciones que no fueron especificadas,
.. 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
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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
Probablemente el caso más significativo, y por tanto el único que vale la pena
mencionar, es la conversión de marcado iterativo a marcado recursivo y luego
a un esquema híbrido. Como se describe en :ref:`dgc_bad`, el marcado iterativo
-tiene sus ventajas, pero tiene desventajas también. Al convertirlo a puramente
-recursivo, es impracticable por resultar en errores de desbordamiento de pila.
+tiene sus ventajas, pero tiene desventajas también. La conversión a puramente
+recursivo resulta impracticable dado que desemboca en errores de
+desbordamiento de pila.
Por lo tanto se prueba con un esquema híbrido, poniendo un límite a la
recursividad, volviendo al algoritmo iterativo cuando se alcanza este límite.
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``.
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.
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
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
*stop-the-world*).
5. Cantidad de memoria usada antes de la recolección.
6. Cantidad de memoria libre antes de la recolección.
-7. Cantidad de memoria desperdiciada antes de la recolección.
+7. Cantidad de memoria desperdiciada [#solwaste]_ antes de la recolección.
8. Cantidad de memoria utilizada por el mismo recolector antes de la
recolección (para sus estructuras internas).
9. Cantidad de memoria usada después de la recolección.
10. Cantidad de memoria libre después de la recolección.
-11. Cantidad de memoria desperdiciada [#solwaste]_ después de la recolección.
+11. Cantidad de memoria desperdiciada después de la recolección.
12. Cantidad de memoria utilizada por el mismo recolector después de la
recolección.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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?
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
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
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 //
function mark_static_data() is
mark_range(static_data.begin, static_data.end,
- global conservative_scan) // Agregado
+ global conservative_ptrmap) // Agregado
function mark_stacks() is
foreach thread in threads
mark_range(thread.stack.begin, thread.stack.end,
- global conservative_scan) // Agregado
+ global conservative_ptrmap) // Agregado
function mark_user_roots() is
foreach root_range in user_roots
mark_range(root_range.begin, root_range.end,
- global conservative_scan) // Agregado
+ global conservative_ptrmap) // Agregado
Las funciones de asignación de memoria se modifican de forma similar, para
guardar el puntero a la información de tipos. Esta implementación utiliza solo
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
: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
Es decir, el *mutator* no puede *resucitar* una celda *muerta* y esta
invariante se mantiene al correr la fase de marcado sobre una vista inmutable
de la memoria. El único efecto introducido es que el algoritmo toma una
-aproximación más conservativa. Es decir, lo que sí puede pasar es que una
-celda que pasó a estar *muerta* una vez que la fase de marcado se inició, pero
-antes de que ésta termine, la celda no se reciclará hasta la próxima
-recolección, dado que este algoritmo no incluye una comunicación entre
-*mutator* y recolector para notificar cambios en el grafo de conectividad.
-Pero esto no afecta la corrección del algoritmo, ya que un recolector es
-correcto cuando nunca recicla celdas *vivas*.
+aproximación más conservativa; una celda que pasó a estar *muerta* luego de
+que se inicie la fase de marcado, pero antes de que termine, puede no ser
+reciclada hasta la próxima recolección, dado que este algoritmo no incluye una
+comunicación entre *mutator* y recolector para notificar cambios en el grafo
+de conectividad. Pero esto no afecta la corrección del algoritmo, ya que un
+recolector es correcto cuando nunca recicla celdas *vivas*.
La única comunicación necesaria entre el *mutator* y el recolector son los
bits de marcado (ver :ref:`dgc_impl`), dado que la fase de barrido debe correr
-en el proceso padre. No es necesaria ningún tipo de sincronización entre
+en el proceso padre. No es necesario ningún tipo de sincronización entre
*mutator* y recolector más allá de que uno espera a que el otro finalice.
Además de almacenar el conjunto de bits ``mark`` en memoria compartida entre
sweep() //
return //
stop_the_world()
- child_pid = fork()
fflush(null)
+ child_pid = fork()
if child_pid is 0 // proceso hijo
mark_phase()
exit(0)
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)
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:
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``::
``-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
^^^^^^^^^^^^^^^^^^^^^^^^^^^
``concpu``
``40 4 bible.txt``
- Procesa 40 veces un archivo de texto plano (de 4MiB de tamaño) [#solbible]_
- utilizando 4 hilos (más el principal).
+ Procesa 40 veces un archivo de texto plano (de 4MiB de tamaño) utilizando
+ 4 hilos (más el principal).
``split``
``bible.txt 2``
- Procesa dos veces un archivo de texto plano (de 4MiB de tamaño)
- [#solbible]_.
+ Procesa dos veces un archivo de texto plano (de 4MiB de tamaño).
``sbtree``
``16``
- Construyen árboles con profundidad máxima 16.
+ Construye árboles con profundidad máxima 16.
``bh``
``-b 4000``
``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``
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
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
al ser una suma de los efectos observados para ``concpu`` y ``split``, con el
agregado de una particularidad extra por la mencionada competencia entre
hilos. A diferencia de ``concpu`` donde el incremento de procesadores resulta
-en un decremento en el tiempo total de ejecución, en este caso resulta en una
-disminución, dado que se necesita mucha sincronización entre hilos, por
+en un decremento en el tiempo total de ejecución, en este caso resulta en un
+incremento, dado que se necesita mucha sincronización entre hilos, por
utilizar todos de forma intensiva los servicios del recolector (y por lo tanto
competir por su *lock* global).
^^^^^^^^
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
forma conservativa, incluso en modo preciso.
También se puede observar una gran disminución del tiempo total de ejecución
-(cerca de un 60%, y más de un 200% comparado con TBGC) alrededor de la mitad)
-al empezar a usar *eager allocation*, acompañado como es usual de una baja en
-la cantidad de recolecciones realizadas (esta vez mayor, de más de 3 veces)
-y de una caída drástica del tiempo de pausa real (alrededor de 40 veces más
-pequeño); todo esto con un incremento marginal en el consumo total de memoria
+al empezar a usar *eager allocation* (cerca de un 60%, y más de un 200%
+comparado con TBGC), acompañado como es usual de una baja en la cantidad de
+recolecciones realizadas (esta vez mayor, de más de 3 veces) y de una caída
+drástica del tiempo de pausa real (alrededor de 40 veces más pequeño); todo
+esto con un incremento marginal en el consumo total de memoria
(aproximadamente un 5%). En este caso el uso de *early collection* apenas
ayuda a bajar el tiempo de pausa real en un 20% en promedio aproximadamente.
El tiempo de *stop-the-world* cae dramáticamente al empezar a realizar la fase
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
projects / z.facultad / 75.00 / informe.git / blobdiff