Pila y Montculo de memoria (Heap and Stack Memory)

Organizacin de lenguajes y compiladores 2

Aux. Oscar Estuardo de la Mora

Pila y Montculo de memoria (Stack memory, Heap Memory)
Las computadoras en lenguaje de bajo nivel deben trabajar en modo de pila al hacer llamadas a mtodos. Por ejemplo si tenemos la siguiente estructura de
cdigo:
void suma(){
//cdigo
}
void main(){
//cdigo
suma();
}

Si tenemos:
void resta(){
//cdigo
}
void suma(){
//cdigo
resta();
}
void main(){
//cdigo
suma();
//cdigo
}
El programa ejecutar primero el mtodo main, y luego
el mtodo suma, pero mientras el mtodo suma esta
ejecutndose, el mtodo main estar esperando.
El programa ejecutar primero el mtodo
main, y luego el mtodo suma, el mtodo
main esta esperando, pero en el mtodo
suma esta llamando al mtodo resta,
entonces el mtodo suma tambin
esperar la finalizacin del mtodo resta.
Luego que el mtodo resta termina,
regresa al mtodo suma y cuando el
mtodo suma termina regresar al mtodo
main.
Pila y Montculo de memoria (Heap and Stack Memory)
Organizacin de lenguajes y compiladores 2
Aux. Oscar Estuardo de la Mora

Conforme se estn llamando los mtodos el tamao de la pila de memoria (stack memory) crece, conforme a los requerimientos que el programa tenga, si
llamamos a un mtodo recursivo por ejemplo:
void factorial(int num){
if(i == 0)
return;
else
factorial(num-1);
}
Este pedir memoria hasta que se cumpla la condicin, por ejemplo:
void main(){
factorial(3);
}




Podemos ver en la grfica que conforme se llaman mtodos, se pide memoria para poder llamar al siguiente mtodo factorial, mientras el otro se queda
esperando a que termine, podemos notar el comportamiento de pila.

El mtodo main llama al mtodo factorial envindole un '3', luego este manda a llamar al mtodo factorial envindole un '2', luego este se vuelve a llamar
con un '1', y este manda a llamarse de nuevo con un '0', como en la condicin del algoritmo dice que cuando sea '0' el nmero, que regrese entonces,
termina el mtodo factorial(0), y se regresa al factorial(1), luego este termina y regresa al factorial(2), este termina y regresa a factorial(3), este termina y
regresa al mtodo main de donde fue llamado originalmente.

Pila y Montculo de memoria (Heap and Stack Memory)
Organizacin de lenguajes y compiladores 2
Aux. Oscar Estuardo de la Mora

Si tenemos un cdigo de esta forma:
void metodo4(){
//cdigo
metodo5();
//cdigo
}
void mtodo2(){
//cdigo
metodo3();
//cdigo
}
void metodo1(){
//cdigo
metodo2();
//cdigo
metodo4();
}
void main(){
//cdigo
metodo1();
//cdigo
metodo6();
//cdigo
}

Primero se llama al mtodo main(), luego este llama al metodo1(), luego este manda a llamar al metodo2(), y este manda a llamar a metodo3(),
metodo3() termina y regresamos a metodo2(), metodo2() termina y regresamos a metodo1(), metodo1() manda a llamar a metodo4(),
metodo4() manda a llamar a metodo5(), luego metodo5() termina y regresamos a metodo4(), luego regresamos a metodo1() y metodo1()
termina, regresamos a main(), luego manda a llamar a metodo6(), metodo6() termina y luego regresamos al main().
Pila y Montculo de memoria (Heap and Stack Memory)
Organizacin de lenguajes y compiladores 2
Aux. Oscar Estuardo de la Mora

El Heap de memoria trabaja de forma distinta, este siempre va a crecer, En el Heap de memoria se guardan los objetos y arreglos que se declaran en un
programa, cuando queremos crear un objeto en el mtodo donde esta declarado tenemos su instancia, su puntero o en otras palabras su direccin de
memoria es contenida en la instancia, y el objeto en si, esta en el Heap.

class Objeto{
int a;
int b;
}

public static void main(){
Objeto obj1 = new Objeto();
Objeto obj2 = new Objeto();
}

Por lo general el espacio de memoria del Heap va a ser mucho mayor que el del Stack
pues va a contener todos los objetos y arreglos. Como podemos ver el mtodo main en el Stack va a tener cierto espacio que ocupan las instancias
declaradas en el, a este espacio se le llama mbito del mtodo. En el mbito del mtodo main() tenemos las direcciones de memoria de los objetos, tambin
podemos ver que los objetos ocupan un espacio en el Heap de memoria, por consiguiente, tambin tienen un mbito en el cual existen. Si cada instancia y
cada entero ocupara una unidad de memoria, el tamao del mtodo main seria '2' y el tamao del objeto en el Heap seria de tamao '2'.

Si tuviramos un cdigo de esta forma:

public void masMemoria(){
Objeto obj1 = new Objeto();
}
public static void main(){
Objeto obj1 = new Objeto;
masMemoria();
}
Pila y Montculo de memoria (Heap and Stack Memory)
Organizacin de lenguajes y compiladores 2
Aux. Oscar Estuardo de la Mora

Podemos ver que el mbito del mtodo main() es de tamao '1' y del mtodo masMemoria() tambin es tamao '1', y he aqu el porque pueden haber
nombres de variables repetidas entre los mtodos, porque sus mbitos son distintos, las declaraciones estn separadas por los mbitos, en este caso, uno
en el main() y otro en el mtodo masMemoria(). Los objetos no son los mismos pues
estn tambin con sus propios mbitos y en distintos lugares en el Heap.

En lenguajes de programacin orientada a objetos como Java se trabajan TODOS los
objetos y arreglos como referencia, es decir, TODAS las declaraciones de objetos y arreglos
son punteros.
Cdigo en C/C++
Objeto * obj;
Es equivalente a decir en Java
Objeto obj;

El contenido de esta variable es una direccin de memoria.

Si tenemos este cdigo
Objeto obj1 = new Objeto();
Objeto obj2 = new Objeto();
Objeto obj3;

Podemos ver que obj1 y obj2 esta apuntando en un lugar en el Heap. Este es un lugar donde el
objeto se esta alojando, para poder acceder al objeto usamos la referencia que tenemos en el
mbito del mtodo main. Tambin podemos notar que obj3 no esta apuntando a ni un lugar, la
razn es porque no se uso el operador new para direccionar y reservar memoria para su
objeto. Ahora bien, que pasa si tenemos esta lnea de cdigo:

obj3 = obj2;

Como vemos en la grfica, obj3 ahora esta apuntando hacia obj2 pues copi su direccin de memoria, ahora se puede acceder a obj2 por medio de obj3.
Pila y Montculo de memoria (Heap and Stack Memory)
Organizacin de lenguajes y compiladores 2
Aux. Oscar Estuardo de la Mora

Ahora bien, que pasa si tenemos el siguiente cdigo

obj2 = obj1;

Ahora obj2 copio la direccin de memoria de obj1, ahora obj1 puede ser modificado
desde obj2, pero... que paso con el objeto donde estaba apuntando obj2
anteriormente? Ahora solo puede ser accedido por obj3.

Pero que pasa si tenemos el siguiente cdigo

obj3 = null;


Pero antes, que es null?
Null es un valor especial que especifica que una referencia esta apuntando a nada.

Pero... que paso con el objeto a donde se estaba apuntando anteriormente?
Este objeto simplemente se perdi, y no puede ser accesado desde ni un lado del
programa, pues nadie esta apuntando hacia el. Pero, que pasa con la memoria que
este ocupaba?, esta tambin se perdi y no se puede recuperar, esta marcada como
ocupada y no puede usarse para crear o colocar nuevos objetos.

A este fenmeno de prdida de memoria se le llama Fuga de memoria o Memory
Leak en ingles, este problema se soluciona con una buena administracin de
memoria por parte del programador si se hace manualmente, mediante mtodos
constructores y destructores (que se vern mas adelante).

Ahora con los nuevos lenguajes de programacin se implementa lo que se llama Recolectores de basura o Garbage Collector en ingles, lo que hace es
poner a disposicin estos bloques perdidos o compactar la memoria para poder usarla mas tarde en el transcurso de la ejecucin del programa.