DEFAULT_PADDING = '0.1'
-# subfig
+# subflt
############################################################################
class subcap(nodes.Part, nodes.TextElement):
self.body.append(']{')
-class subfig(nodes.General, nodes.Element):
+class subflt(nodes.General, nodes.Element):
pass
-def latex_visit_subfig(self, node):
+def latex_visit_subflt(self, node):
space = '\\hspace{%sin}\n' % node['space'] if node['space'] else ''
self.body.append(space)
self.body.append('\\subfloat')
-def latex_depart_subfig(self, node):
+def latex_depart_subflt(self, node):
self.body.append('}\n')
-class SubfigDirective(Directive):
+class SubfltDirective(Directive):
has_content = True
required_arguments = 0
def run(self):
self.assert_has_content()
- subfig_node = subfig('\n'.join(self.content))
- subfig_node['label'] = self.options.get('label', None)
- subfig_node['space'] = self.options.get('space', None)
+ subflt_node = subflt('\n'.join(self.content))
+ subflt_node['label'] = self.options.get('label', None)
+ subflt_node['space'] = self.options.get('space', None)
if self.arguments and self.arguments[0]:
- subfig_node['label'] = self.arguments[0]
+ subflt_node['label'] = self.arguments[0]
node = nodes.Element() # anonymous container for parsing
self.state.nested_parse(self.content, self.content_offset, node)
first_node = node[0]
if isinstance(first_node, nodes.paragraph):
cap = subcap(first_node.rawsource, '', *first_node.children)
- subfig_node += cap
- subfig_node += node[1:]
+ subflt_node += cap
+ subflt_node += node[1:]
else:
- subfig_node += subcap('', '', nodes.Text(''))
- subfig_node += node[:]
- return [subfig_node]
+ subflt_node += subcap('', '', nodes.Text(''))
+ subflt_node += node[:]
+ return [subflt_node]
-# fig
+# captions / padding
############################################################################
class captitle(nodes.Part, nodes.TextElement):
#self.body.append('\\hspace{%sin}\n' % DEFAULT_PADDING) #node['inches'])
-class fig(nodes.General, nodes.Element):
+
+# flt
+############################################################################
+
+class flt(nodes.General, nodes.Element):
pass
-def latex_visit_fig(self, node):
- self.body.append('\\begin{figure}[%s]\n' % node['placement'])
+def latex_visit_flt(self, node):
+ self.body.append('\\begin{%s}[%s]\n' % (node['type'], node['placement']))
self.body.append('' if node['nocenter'] else '\\centering\n')
-def latex_depart_fig(self, node):
+def latex_depart_flt(self, node):
label = '\\label{%s}\n' % node['label'] if node['label'] else ''
self.body.append(label)
- self.body.append('\\end{figure}\n\n')
+ self.body.append('\\end{%s}\n\n' % node['type'])
+
+class FltDirective(Directive):
-class FigDirective(Directive):
+ flt_types = ('figure', 'table')
+ def flt_type(argument):
+ # This is not callable as self.align. We cannot make it a
+ # staticmethod because we're saving an unbound method in
+ # option_spec below.
+ return directives.choice(argument, FltDirective.flt_types)
has_content = True
required_arguments = 0
optional_arguments = 1
final_argument_whitespace = True
option_spec = dict(
+ type = flt_type,
label = directives.unchanged,
placement = directives.unchanged,
padding = float,
def run(self):
self.assert_has_content()
- fig_node = fig('\n'.join(self.content))
- fig_node['label'] = self.options.get('label', None)
- fig_node['placement'] = self.options.get('placement', DEFAULT_PLACES)
- fig_node['padding'] = self.options.get('padding', DEFAULT_PADDING)
- fig_node['nocenter'] = 'nocenter' in self.options
+ flt_node = flt('\n'.join(self.content))
+ flt_node['type'] = self.options.get('type', 'figure')
+ flt_node['label'] = self.options.get('label', None)
+ flt_node['placement'] = self.options.get('placement', DEFAULT_PLACES)
+ flt_node['padding'] = self.options.get('padding', DEFAULT_PADDING)
+ flt_node['nocenter'] = 'nocenter' in self.options
if self.arguments and self.arguments[0]:
- fig_node['label'] = self.arguments[0]
+ flt_node['label'] = self.arguments[0]
node = nodes.Element() # anonymous container for parsing
self.state.nested_parse(self.content, self.content_offset, node)
first_node = None
node = node[2:]
elif is_first_para:
capt = captitle(first_node.rawsource, '', *first_node.children)
- capd = capdesc(first_node.rawsource, '', *first_node.children)
+ capt = capdesc(first_node.rawsource, '', *first_node.children)
node = node[1:]
elif is_second_para:
capt = captitle(second_node.rawsource, '', *second_node.children)
first = True
children = []
for n in node:
- if isinstance(n, subfig):
+ if isinstance(n, subflt):
if first:
first = False
else:
children.append(pad('', '', nodes.Text(''),
- inches=fig_node['padding']))
+ inches=flt_node['padding']))
children.append(n)
- fig_node += children
+ flt_node += children
if capt and capd:
- fig_node += capt
- fig_node += capd
- return [fig_node]
+ flt_node += capt
+ flt_node += capd
+ return [flt_node]
def setup(app):
app.add_node(subcap, latex=(latex_visit_subcap, latex_depart_subcap))
- app.add_node(subfig, latex=(latex_visit_subfig, latex_depart_subfig))
+ app.add_node(subflt, latex=(latex_visit_subflt, latex_depart_subflt))
app.add_node(captitle, latex=(latex_visit_captitle, latex_depart_captitle))
app.add_node(capdesc, latex=(latex_visit_capdesc, latex_depart_capdesc))
app.add_node(pad, latex=(latex_visit_pad, latex_depart_pad))
- app.add_node(fig, latex=(latex_visit_fig, latex_depart_fig))
- app.add_directive('fig', FigDirective)
- app.add_directive('subfig', SubfigDirective)
+ app.add_node(flt, latex=(latex_visit_flt, latex_depart_flt))
+ app.add_directive('flt', FltDirective)
+ app.add_directive('subflt', SubfltDirective)
# vim: set et sw=4 sts=4 :
+++ /dev/null
-
-from docutils import nodes, utils
-from docutils.parsers.rst import directives
-from sphinx.util.compat import Directive
-
-
-DEFAULT_PLACES = 'btp'
-DEFAULT_PADDING = '0.1'
-
-
-# subtable
-############################################################################
-
-class subtcap(nodes.Part, nodes.TextElement):
- pass
-
-def latex_visit_subtcap(self, node):
- self.body.append('[')
-
-def latex_depart_subtcap(self, node):
- self.body.append(']{')
-
-
-class subtable(nodes.General, nodes.Element):
- pass
-
-def latex_visit_subtable(self, node):
- space = '\\hspace{%sin}\n' % node['space'] if node['space'] else ''
- self.body.append(space)
- self.body.append('\\subfloat')
-
-def latex_depart_subtable(self, node):
- self.body.append('}\n')
-
-
-class SubtableDirective(Directive):
-
- has_content = True
- required_arguments = 0
- optional_arguments = 1
- final_argument_whitespace = True
- option_spec = dict(
- label = directives.unchanged,
- space = float,
- )
-
- def run(self):
- self.assert_has_content()
- subtable_node = subtable('\n'.join(self.content))
- subtable_node['label'] = self.options.get('label', None)
- subtable_node['space'] = self.options.get('space', None)
- if self.arguments and self.arguments[0]:
- subtable_node['label'] = self.arguments[0]
- node = nodes.Element() # anonymous container for parsing
- self.state.nested_parse(self.content, self.content_offset, node)
- first_node = node[0]
- if isinstance(first_node, nodes.paragraph):
- cap = subtcap(first_node.rawsource, '', *first_node.children)
- subtable_node += cap
- subtable_node += node[1:]
- else:
- subtable_node += subtcap('', '', nodes.Text(''))
- subtable_node += node[:]
- return [subtable_node]
-
-
-# ftable
-############################################################################
-
-class captitle(nodes.Part, nodes.TextElement):
- pass
-
-def latex_visit_captitle(self, node):
- self.body.append('\\caption[')
-
-def latex_depart_captitle(self, node):
- self.body.append(']')
-
-class capdesc(nodes.Part, nodes.TextElement):
- pass
-
-def latex_visit_capdesc(self, node):
- self.body.append('{')
-
-def latex_depart_capdesc(self, node):
- self.body.append('}\n')
-
-class tpad(nodes.Part, nodes.TextElement):
- pass
-
-def latex_visit_tpad(self, node):
- self.body.append('\\hspace{%sin}\n' % node['inches'])
-
-def latex_depart_tpad(self, node):
- pass
- #self.body.append('\\hspace{%sin}\n' % DEFAULT_PADDING) #node['inches'])
-
-
-class ftable(nodes.General, nodes.Element):
- pass
-
-def latex_visit_ftable(self, node):
- self.body.append('\\begin{table}[%s]\n' % node['placement'])
- self.body.append('' if node['nocenter'] else '\\centering\n')
-
-def latex_depart_ftable(self, node):
- label = '\\label{%s}\n' % node['label'] if node['label'] else ''
- self.body.append(label)
- self.body.append('\\end{table}\n\n')
-
-class FTableDirective(Directive):
-
- has_content = True
- required_arguments = 0
- optional_arguments = 1
- final_argument_whitespace = True
- option_spec = dict(
- label = directives.unchanged,
- placement = directives.unchanged,
- padding = float,
- nocenter = directives.flag,
- )
-
- def run(self):
- self.assert_has_content()
- ftable_node = ftable('\n'.join(self.content))
- ftable_node['label'] = self.options.get('label', None)
- ftable_node['placement'] = self.options.get('placement', DEFAULT_PLACES)
- ftable_node['padding'] = self.options.get('padding', DEFAULT_PADDING)
- ftable_node['nocenter'] = 'nocenter' in self.options
- if self.arguments and self.arguments[0]:
- ftable_node['label'] = self.arguments[0]
- node = nodes.Element() # anonymous container for parsing
- self.state.nested_parse(self.content, self.content_offset, node)
- first_node = None
- second_node = None
- try:
- first_node = node[0]
- second_node = node[1]
- except IndexError:
- pass
- is_first_para = isinstance(first_node, nodes.paragraph)
- is_second_para = isinstance(second_node, nodes.paragraph)
- capt = None
- capd = None
- if is_first_para and is_second_para:
- capt = captitle(first_node.rawsource, '', *first_node.children)
- capd = capdesc(second_node.rawsource, '', *second_node.children)
- node = node[2:]
- elif is_first_para:
- capt = captitle(first_node.rawsource, '', *first_node.children)
- capd = capdesc(first_node.rawsource, '', *first_node.children)
- node = node[1:]
- elif is_second_para:
- capt = captitle(second_node.rawsource, '', *second_node.children)
- capd = capdesc(second_node.rawsource, '', *second_node.children)
- node = node[1:]
- first = True
- children = []
- for n in node:
- if isinstance(n, subtable):
- if first:
- first = False
- else:
- children.append(tpad('', '', nodes.Text(''),
- inches=ftable_node['padding']))
- children.append(n)
- ftable_node += children
- if capt and capd:
- ftable_node += capt
- ftable_node += capd
- return [ftable_node]
-
-
-
-def setup(app):
- app.add_node(subtcap, latex=(latex_visit_subtcap, latex_depart_subtcap))
- app.add_node(subtable, latex=(latex_visit_subtable, latex_depart_subtable))
- app.add_node(captitle, latex=(latex_visit_captitle, latex_depart_captitle))
- app.add_node(capdesc, latex=(latex_visit_capdesc, latex_depart_capdesc))
- app.add_node(tpad, latex=(latex_visit_tpad, latex_depart_tpad))
- app.add_node(ftable, latex=(latex_visit_ftable, latex_depart_ftable))
- app.add_directive('ftable', FTableDirective)
- app.add_directive('subtable', SubtableDirective)
-
-
-# vim: set et sw=4 sts=4 :
precio sin obtener los beneficios. Queda pendiente analizar en más detalle
las causas de esto y posibles optimizaciones para subsanarlo.
- .. ftable:: t:con-staticsize
+ .. flt:: t:con-staticsize
+ :type: table
Aumento del tamaño de la memoria estática (bytes).
pérdida de rendimiento, dado que puede afectar a la localidad de referencia
del caché, por ejemplo.
- .. ftable:: t:con-binsize
+ .. flt:: t:con-binsize
+ :type: table
Aumento del tamaño del binario (bytes).
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
-sys.path.append(os.path.abspath('../ext'))
+sys.path.insert(0, os.path.abspath('../ext'))
# -- General configuration -----------------------------------------------------
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = [
'aafig',
- 'fig',
- 'ftable',
+ 'flt',
'vref',
'pcodehl',
'sphinx.ext.graphviz',
para indicar la continuación de un objeto grande (que ocupan más de una
página).
-.. fig:: fig:dgc-org
+.. flt:: fig:dgc-org
Organización del *heap* del recolector de basura actual de D.
:vref:`fig:dgc-free-list`). Esto permite asignar objetos relativamente
pequeños de forma bastante eficiente.
-.. fig:: fig:dgc-free-list
+.. flt:: fig:dgc-free-list
Ejemplo de listas de libres.
La estructura ``Pool`` está compuesta por los siguientes atributos (ver figura
:vref:`fig:dgc-pool`):
-.. fig:: fig:dgc-pool
+.. flt:: fig:dgc-pool
Vista gráfica de la estructura de un *pool* de memoria.
bits estén intactas. Esto permite detectar de forma temprana errores tanto
en el recolector como en el programa del usuario.
- .. fig:: fig:sentinel
+ .. flt:: fig:sentinel
Esquema de un bloque cuando está activada la opción ``SENTINEL``.
:vref:`fig:gc-heap-parts`).
-.. fig:: fig:gc-heap-parts
+.. flt:: fig:gc-heap-parts
Distintas partes de la memoria *heap*.
*basura* (en blanco).
-.. fig:: fig:gc-mark-1
+.. flt:: fig:gc-mark-1
Ejemplo de marcado del grafo de conectividad (parte 1).
- .. subfig::
+ .. subflt::
Se comienza a marcar el grafo por la raíz r0.
}
- .. subfig::
+ .. subflt::
Luego de marcar el nodo ``h1``, se procede al ``h2``.
}
- .. subfig::
+ .. subflt::
Luego sigue el nodo h5.
}
-.. fig:: fig:gc-mark-2
+.. flt:: fig:gc-mark-2
Ejemplo de marcado del grafo de conectividad (parte 2).
- .. subfig::
+ .. subflt::
El nodo h5 tiene una arista al h1, pero el h1 ya fue visitado, por lo
tanto no se visita nuevamente.
}
- .. subfig::
+ .. subflt::
Se concluye el marcado del sub-grafo al que conecta r0, se procede
a marcar el sub-grafo al que conecta r1, marcando al nodo h6.
}
- .. subfig::
+ .. subflt::
El nodo h6 tiene una arista al h2, pero éste ya fue marcado por lo
que no se vuelve a visitar. No hay más raíces, se finaliza el marcado
*live set* ya que sus contadores siguen siendo mayores a 0 (ver figura
:vref:`fig:gc-rc-rm-2`).
-.. fig:: fig:gc-rc-rm-1
+.. flt:: fig:gc-rc-rm-1
Ejemplo de conteo de referencias: eliminación de una referencia (parte 1).
Eliminación de la referencia ``r0`` :math:`\to` ``h1`` (parte 1).
- .. subfig::
+ .. subflt::
Estado inicial del grafo de conectividad.
}
- .. subfig::
+ .. subflt::
Al ejecutarse ``update(r0, null)``, se comienza por visitar la celda
``h1``.
}
- .. subfig::
+ .. subflt::
Se decrementa el contador de ``h1`` quedando en 0 (pasa a ser *basura*).
Se elimina primero ``h1.l`` y luego ``h1.r``.
}
-.. fig:: fig:gc-rc-rm-2
+.. flt:: fig:gc-rc-rm-2
:padding: 0.5
Ejemplo de conteo de referencias: eliminación de una referencia (parte 2).
Eliminación de la referencia ``r0`` :math:`\to` ``h1`` (parte 2).
- .. subfig::
+ .. subflt::
Se decrementa el contador de ``h2`` pero no queda en 0 (permanece en el
*live set*).
}
- .. subfig::
+ .. subflt::
El contador de ``h3`` tampoco queda en 0, sigue en el *live set*.
contador de ``h2`` que queda en 0, transformándose en *basura* (ver figura
:vref:`fig:gc-rc-up-1`).
-.. fig:: fig:gc-rc-up-1
+.. flt:: fig:gc-rc-up-1
Ejemplo de conteo de referencias: actualización de una referencia (parte 1).
Cambio en la referencia ``h3.l`` :math:`\to` ``h2`` a ``h3.l`` :math:`\to`
``h5`` (parte 1).
- .. subfig::
+ .. subflt::
Comienza ``update(h3.l, h5)``, se incrementa el contador de ``h5``.
}
- .. subfig::
+ .. subflt::
Luego se procede a visitar la antigua referencia de ``h3.l`` (``h2``).
}
- .. subfig::
+ .. subflt::
Se decrementa el contador de ``h2`` y queda en 0 (pasa a ser *basura*).
Se eliminan las referencias a las hijas.
de actualizar la referencia ``h3.l`` para que apunte a ``h5`` (ver figura
:vref:`fig:gc-rc-up-2`).
-.. fig:: fig:gc-rc-up-2
+.. flt:: fig:gc-rc-up-2
Ejemplo de conteo de referencias: actualización de una referencia (parte 2).
Cambio en la referencia ``h3.l`` :math:`\to` ``h2`` a ``h3.l`` :math:`\to`
``h5`` (parte 2).
- .. subfig::
+ .. subflt::
Se decrementa el contador de ``h4`` quedando en 0, pasa a ser *basura*.
Se continúa con ``h5``.
}
- .. subfig::
+ .. subflt::
Se decrementa el contador de ``h5`` pero sigue siendo mayor que 0.
}
- .. subfig::
+ .. subflt::
Se termina por actualizar la referencia de ``h3.l`` para que apunte
a ``h5``.
pueden ser recicladas y su memoria es perdida (ver figura
:vref:`fig:gc-rc-cycle`).
-.. fig:: fig:gc-rc-cycle
+.. flt:: fig:gc-rc-cycle
:padding: 0.5
Ejemplo de conteo de referencias: pérdida de memoria debido a un ciclo.
Eliminación de la referencia ``r1`` :math:`\to` ``h3`` (pérdida de memoria
debido a un ciclo).
- .. subfig::
+ .. subflt::
El ejecutarse ``update(r1, null)`` se visita la celda ``h3``.
}
- .. subfig::
+ .. subflt::
Se decrementa el contador de ``h3`` pero sigue siendo mayor que 0 por el
ciclo.
sucede y se acumulan muchos *huecos* se dice que la memoria está
*fragmentada*.
-.. fig:: fig:gc-copy
+.. flt:: fig:gc-copy
Estructura del *heap* de un recolector con copia de semi-espacios.
*forwarding address* a la nueva ubicación (ver figura
:vref:`fig:gc-copy-ex-1`).
-.. fig:: fig:gc-copy-ex-1
+.. flt:: fig:gc-copy-ex-1
Ejemplo de recolección con copia de semi-espacios (parte 1).
- .. subfig::
+ .. subflt::
Estructura inicial del *heap*. El *Fromspace* está complete y se inicial
la recolección.
| "Tospace" |
+--------------------------------------------------+
- .. subfig::
+ .. subflt::
Se sigue la referencia del *root set*, copiando ``h3`` al *Tospace*
y dejando una *forwarding address*.
ubicación de ``h2`` pero no se vuelve a copiar la celda (ver figura
:vref:`fig:gc-copy-ex-2`).
-.. fig:: fig:gc-copy-ex-2
+.. flt:: fig:gc-copy-ex-2
Ejemplo de recolección con copia de semi-espacios (parte 2).
- .. subfig::
+ .. subflt::
Se sigue :math:`h3 \to h2`, copiando ``h2`` al *Tospace* y dejando una
*forwarding address*.
| "Tospace" |
+--------------------------------------------------+
- .. subfig::
+ .. subflt::
Se sigue :math:`h2 \to h1`, copiando ``h1``. Luego :math:`h1 \to h2`
pero ``h2`` no se copia, sólo se actualiza la referencia con la
nueva ubicación de ``h3``, como se muestra en la figura
:vref:`fig:gc-copy-ex-3`.
-.. fig:: fig:gc-copy-ex-3
+.. flt:: fig:gc-copy-ex-3
Ejemplo de recolección con copia de semi-espacios (parte 3).
- .. subfig::
+ .. subflt::
Se sigue :math:`h1 \to h4` copiando `h4`` al *Tospace* y dejando una
*forwarding address*.
| "Tospace" \------/ |
+--------------------------------------------------+
- .. subfig::
+ .. subflt::
Se finaliza la recolección, se intercambian los roles de los
semi-espacios y se actualiza la referencia del *root set*.
disponibles para realizar la recolección (ver figura
:vref:`fig:gc-concurrent`).
-.. fig:: fig:gc-concurrent
+.. flt:: fig:gc-concurrent
Distintos tipos de recolectores según el comportamiento en ambientes
multi-hilo.
- .. subfig::
+ .. subflt::
*Stop-the-world*.
| HH Mutator ZZ Inactivo XX Recolector |
|___________________________________________________________________|
- .. subfig::
+ .. subflt::
Paralelo.
| HH Mutator ZZ Inactivo XX Recolector |
|___________________________________________________________________|
- .. subfig::
+ .. subflt::
Concurrente.
alta concentración de *basura* puede hacer la recolección solo en ese área
donde el trabajo va a ser mejor recompensado (ver figura :vref:`fig:gc-part`).
-.. fig:: fig:gc-part
+.. flt:: fig:gc-part
Concentración de basura en distintas particiones del *heap*.
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
``MAX_DEPTH``.
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.
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``.
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
tipo.
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.
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.
voronoi 0.886 0.003 0.006
======== ======== ======== ========
- .. subtable::
+ .. subflt::
Del consumo máximo de memoria.
programa real, por lo que los resultados deben ser analizados teniendo esto
presente.
-.. fig:: fig:sol-bigarr-1cpu
+.. flt:: fig:sol-bigarr-1cpu
Resultados para ``bigarr`` (utilizando 1 procesador).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-bigarr-1cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
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).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-bigarr-4cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
Pausa real máxima (seg)
.. image:: plots/pause-bigarr-4cpu.pdf
-.. fig:: fig:sol-concpu-1cpu
+.. flt:: fig:sol-concpu-1cpu
Resultados para ``concpu`` (utilizando 1 procesador).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-concpu-1cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
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).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-concpu-4cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
Pausa real máxima (seg)
.. image:: plots/pause-concpu-4cpu.pdf
-.. fig:: fig:sol-conalloc-1cpu
+.. flt:: fig:sol-conalloc-1cpu
Resultados para ``conalloc`` (utilizando 1 procesador).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-conalloc-1cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
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).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-conalloc-4cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
Pausa real máxima (seg)
.. image:: plots/pause-conalloc-4cpu.pdf
-.. fig:: fig:sol-split-1cpu
+.. flt:: fig:sol-split-1cpu
Resultados para ``split`` (utilizando 1 procesador).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-split-1cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
Pausa real máxima (seg)
.. image:: plots/pause-split-1cpu.pdf
-.. fig:: fig:sol-mcore-1cpu
+.. flt:: fig:sol-mcore-1cpu
Resultados para ``mcore`` (utilizando 1 procesador).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-mcore-1cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
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).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-mcore-4cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
Pausa real máxima (seg)
.. image:: plots/pause-mcore-4cpu.pdf
-.. fig:: fig:sol-rnddata-1cpu
+.. flt:: fig:sol-rnddata-1cpu
Resultados para ``rnddata`` (utilizando 1 procesador).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-rnddata-1cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
Pausa real máxima (seg)
Resultados para pruebas pequeñas
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-.. fig:: fig:sol-bh-1cpu
+.. flt:: fig:sol-bh-1cpu
Resultados para ``bh`` (utilizando 1 procesador).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-bh-1cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
Pausa real máxima (seg)
``bh``
^^^^^^
-.. ftable:: t:sol-prec-mem-bh
+.. flt:: t:sol-prec-mem-bh
+ :type: table
Memoria pedida y asignada para ``bh`` según modo de marcado.
en la cantidad de recolecciones efectuadas (aunque no se traduzca en un menor
consumo de memoria).
-.. fig:: fig:sol-bisort-1cpu
+.. flt:: fig:sol-bisort-1cpu
Resultados para ``bisort`` (utilizando 1 procesador).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-bisort-1cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
Pausa real máxima (seg)
usa marcado conservativo y preciso. Estos valores fueron tomados usando la
opción ``malloc_stats_file`` (ver :ref:`sol_stats`).
-.. fig:: fig:sol-em3d-1cpu
+.. flt:: fig:sol-em3d-1cpu
Resultados para ``em3d`` (utilizando 1 procesador).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-em3d-1cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
Pausa real máxima (seg)
configuraciones del último (evidentemente en este caso no se aprovecha el
caché de ``findSize()``).
-.. fig:: fig:sol-tsp-1cpu
+.. flt:: fig:sol-tsp-1cpu
Resultados para ``tsp`` (utilizando 1 procesador).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-tsp-1cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
Pausa real máxima (seg)
este caso el marcado preciso y el uso de *early collection** no parecen
ayudar; por el contrario, aumentan levemente el tiempo de pausa real.
-.. fig:: fig:sol-voronoi-1cpu
+.. flt:: fig:sol-voronoi-1cpu
Resultados para ``voronoi`` (utilizando 1 procesador).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-voronoi-1cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
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).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-voronoi-4cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
Pausa real máxima (seg)
Resultados para pruebas reales
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-.. fig:: fig:sol-dil-1cpu
+.. flt:: fig:sol-dil-1cpu
Resultados para ``dil`` (utilizando 1 procesador).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-dil-1cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
Pausa real máxima (seg)
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.
-.. fig:: fig:sol-dil-4cpu
+.. flt:: fig:sol-dil-4cpu
Resultados para ``dil`` (utilizando 4 procesadores).
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
- .. subfig::
+ .. subflt::
Cantidad de recolecciones
.. image:: plots/ncol-dil-4cpu.pdf
- .. subfig::
+ .. subflt::
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
- .. subfig::
+ .. subflt::
Pausa real máxima (seg)
En el cuadro :vref:`t:sol-prec-mem-dil` se puede observar la diferencia de
memoria desperdiciada entre el modo conservativo y 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.
projects / z.facultad / 75.00 / informe.git / commitdiff