Los programas pueden hacer uso principalmente de 4 áreas de memoria:
-Registros:
+Registros
Se trata de la memoria más básica de una computadora. Es el área de memoria
en la que puede operar realmente el procesador, es extremadamente escasa
y generalmente su uso es administrado por el lenguaje de programación (o
realizando tareas de muy bajo nivel, un programador nunca manipula los
registros explícitamente.
-Área de memoria estática:
+Área de memoria estática
Es la forma de memoria más simple que un programador utiliza
explícitamente. En general las variables globales se almacenan en este
área, que es parte inherente del programa y está disponible durante toda su
compilación**. Los primeros lenguajes de programación solo contaban con
este tipo de memoria (además de los registros del procesador).
-*Stack* (pila):
+*Stack* (pila)
Los primeros lenguajes de programación que hicieron uso de una pila
aparecieron en el año 1958 (Algol-58 y Atlas Autocode) y fueron los
primeros en introducir estructura de bloques, almacenando las variables
a otra cosa, como al nodo de una lista o a un objeto en el sentido de
programación orientada a objetos).
-*Heap*:
+*Heap*
A diferencia del *stack*, el *heap* provee un área de memoria que puede ser
obtenida dinámicamente pero sin limitaciones de orden. Es el tipo de
memoria más flexible y por lo tanto el más complejo de administrar; razón
Más formalmente, Definimos:
-*Camino*:
+*Camino*
secuencia de vértices tal que cada uno de los vértices tiene una arista al
próximo vértice en la secuencia. Todo camino finito tiene un *vértice
inicial* y un *vértice final* (llamados en conjunto *vértices terminales*).
\exists (v_i \to v_{i+1}) \in A
\right\rbrace
-*Conexión*:
+*Conexión*
decimos que :math:`M` está *conectado* a :math:`N` si y sólo si existe un
camino de :math:`M` a :math:`N`.
M \mapsto N \Longleftrightarrow \exists \underset{M \to N}{C} \in G
-*Live set*:
+*Live set*
el conjunto de celdas *vivas* está dado por todos los vértices (:math:`v`)
del grafo para los cuales existe una raíz en el *root set* que esté
conectada a él.
\left( \exists r \in Root \thickspace set \big/ r \mapsto v \right)
\right\rbrace
-*Basura*:
+*Basura*
la basura, o celdas *muertas*, quedan determinadas entonces por todas las
celdas del *heap* que no son parte del *live set*.
vez son tres porciones: blanca, gris y negra.
Al principio todas las celdas se pintan de blanco, excepto el *root set* que
-se punta de gris. Luego se van obteniendo celdas del conjunto de las grises
+se pinta de gris. Luego se van obteniendo celdas del conjunto de las grises
y se las pinta de negro, pintando sus hijas directas de gris.
Una vez que no hay más celdas grises, tenemos la garantía de que las celdas
v = gray_set.pop()
black_set.add(v)
for (src, dst) in v.edges
- if v in white_set
- white_set.remove(v)
- gray_set.add(v)
+ if dst in white_set
+ white_set.remove(dst)
+ gray_set.add(dst)
-Es simple notar que este algoritmo es naturalmente no recursivo, lo que de por
-sí ya presenta una ventaja sobre el marcado *bicolor*.
+Si bien este algoritmo no es recursivo, tiene un requerimiento de espacio
+:math:`O(\lvert Live \thickspace set \rvert)`. Un ejemplo donde se aprecia
+esto a simple vista es cuando el *live set* resulta una lista simplemente
+enlazada, en cuyo caso el :math:`gray_set` deberá almacenar todos los nodos
+del *live set*.
Servicios utilizados por el recolector son los siguientes:
-:math:`alloc() \to cell`:
+:math:`alloc() \to cell`
obtiene una nueva celda de memoria. El mecanismo por el cual se obtiene la
celda es indistinto para esta sección, puede ser de una lista libre, puede
ser de un administrador de memoria de más bajo nivel provisto por el
contrario) que las celdas son de tamaño fijo. Esta restricción normalmente
puede ser fácilmente relajada (en los recolectores que la tienen).
-:math:`free(cell)`:
+:math:`free(cell)`
libera una celda que ya no va a ser utilizada. La celda liberada debe haber
sido obtenida mediante ``alloc()``.
Y los servicios básicos proporcionados por el recolector son los siguientes:
-:math:`new() \to cell`:
+:math:`new() \to cell`
obtiene una celda de memoria para ser utilizada por el programa.
-:math:`update(ref, cell)`:
+:math:`update(ref, cell)`
notifica al recolector que la referencia :math:`ref` ahora apunta
a :math:`cell`. Visto más formalmente, sería análogo a decir que hubo un
cambio en la conectividad del grafo: la arista :math:`src \to old` cambia
:math:`cell` es ``null``, sería análogo a informar que se elimina la arista
:math:`src \to old`.
-:math:`del(cell)`:
+:math:`del(cell)`
este servicio, según el algoritmo, puede ser utilizado para informar un
cambio en la conectividad del grafo, la eliminación de una arista (análogo
a :math:`update(ref, null)` pero sin proporcionar información sobre la
a eliminar el conjunto de aristas :math:`\big\lbrace (v, w) \in A , v \in
Live \thickspace set , w \in Live \thickspace set \big/ w = cell`.
-:math:`collect()`:
+:math:`collect()`
indica al recolector que debe hacer un análisis del grafo de conectividad
en busca de *basura*. Generalmente este servicio es invocado por el propio
recolector cuando no hay más celdas reciclables.
*Stop-the-world*.
.. aafig::
- :scale: 115
+ :scale: 110
:aspect: 70
___________________________________________________________________
Paralelo.
.. aafig::
- :scale: 115
+ :scale: 110
:aspect: 70
___________________________________________________________________
Concurrente.
.. aafig::
- :scale: 115
+ :scale: 110
:aspect: 70
___________________________________________________________________
.. include:: links.rst
-.. vim: set ts=3 sts=3 sw=3 et tw=78 :
+.. vim: set ts=3 sts=3 sw=3 et tw=78 spelllang=es :
projects / z.facultad / 75.00 / informe.git / blobdiff