Me lo contaron y lo olvidé, lo leí y lo entendí, lo hice y lo aprendí.





lunes, 31 de octubre de 2011

[Programación] Simulador de gestor de memoria

Vale programadores, aquí hay una guía de cómo pueden simular un gestor de memoria.
Primero que nada ya deberían tener programada al menos una de las políticas para el gestor de procesos, en el cual deben tener una estructura (array, cola, pila, arbol, etc) en dónde guardan los procesos en pausa (ya se inició su tiempo de ejecución pero no están precisamente en ejecución).

Si ya tienen una política así sáltense casi hasta el final, si no es así les echaré una mano ;)
Ya está la base para la política FCFS (Primero en entrar, primer en ser servido) justo AQUÍ; parece que todo está explicado más o menos decente (Comprendan que lo escribí hace como 1 mes y en 1 hora...) pero como se ve, en esta política no contemplé que existiera una estructura para especificar qué procesos están en la memoria (en espera de ser ejecutados) y cuales no; tendremos que crear una y lo ideal es una cola... espero por su bien que recuerden cómo es una cola, si no es así pues a googlear. Vale yo encontré estos 2 sitios que les pueden servir:
Crear clase cola en java
Colas en java

Les puse en java por que supongo que allí lo harán... y por que no les voy a poner en C#, verdad?

Ahora, en ésta cola iremos metiendo los procesos que hayan tanto llegado su tiempo de ejecución como los que quepan en la memoria (o sea que deben cumplir las dos condiciones). Así, cada vez que un proceso se ejecuta, metemos a ésta cola el (los) procesos que cumplen estas condiciones y ya será de ésta cola que sacaremos los procesos a ejecución, vale?

Primero hay que modificar la clase proceso para que tengan un valor para el espacio en memoria (por ejemplo int espacio;)
La memoria puede ser un simple arreglo de x espacios (que será el espacio de la memoria), y si un proceso ocupa 5 de espacio, entonces ocupará 5 espacios o cuadritos del arreglo memoria. ¿Cómo indicar que un espacio del arreglo está ocupado por una parte de un proceso? Pues hay muchas alternativas, una de ellas es que el arreglo memorial sea del tipo Proceso y que apunte al proceso que le ocupa, así si un espacio está libre tendrá un valor null, sino es así tendrá un puntero al proceso (o sea no será null); otro es que sea del tipo string y que guarde el nombre del proceso... en fin ustedes sabrán como darle originalidad al programa.
Ahora explicaré algo, los procesos que están en la cola serán los mismos que están en la memoria, la cuestión es que en la memoria se debe representar la ubicación y el espacio ocupado por cada proceso (tanto en gestión segmentada y paginada).

Bueno, ya teniendo la memoria (el arreglo memoria) hecho, necesitamos controlar los procesos que entran y salen de ella; para ello crearemos funciones.

Primero las funciones para ver si un proceso puede caber en la memoria (mmm... me refiero a checar si cabe en la cola, si no cabe en la memoria pues no entrará en la cola).

Para al segmentada es muy sencillo, solo checamos los espacios de la memoria libres y si son iguales o más que el tamaño del proceso entonces va para adentro, sino, pues no :P

public boolean cabe(int tamañoDelProceso)
{
  int espacios=0;
  for(int i=0;i<memoria.lenght;i++)
  {
    if(memoria[i]==null) //Suponiendo el caso de que aputámos al proceso que ocupa la memoria
    {
      espacios++;
    }
  }
  if(espacios>=tamañoDelProceso)
  {
    return true;
  }
  else
  {
    return false;
  }
}

Para la paginada es muy parecido, sólo que en este caso es necesario determinar de cuántos espacios será la paginación (debe ser un divisor entero del tamaño de la memoria, esto es si la memoria es de 30 espacios la paginación puede ser de 3,5 o 6); de allí (suponiendo que la paginación es de 6) sólo buscamos los espacios de 6 en 6 y ver si están libres, si lo están es obvio que los otros 5 espacios adyacentes estarán libres; sacamos otra vez el total de espacios libres y hacemos el mismo procedimiento.

public boolean cabePaginada(int tamañoDelProceso)
{
  int espacios=0;
  for(int i=0;i<memoria.lenght;i+=6)
  {
    if(memoria[i]==null) //Suponiendo el caso de que aputámos al proceso que ocupa la memoria
    {
      espacios++;
    }
  }
  if(espacios*6>=tamañoDelProceso)
  {
    return true;
  }
  else
  {
    return false;
  }
}

fácil, no?

Ahora a meterlos. Para la segmentada (como siempre) será sencillo, sólo hay que meter el proceso en tantos huecos espacios libres como espacio ocupe éste proceso. O sea que si el proceso ocupa 5 espacios entonces lo meteremos en 5 espacios libres.

public void meter(Proceso proceso)
{
  int espacios=0;
  for(int i=0;i<memoria.length;i++)
  {
    if(memoria[i]==null & espacios<proceso.espacio)
    {
      memoria[i]=proceso;
      espacios++;
    }
  }
}

Para la paginada necesitamos avanzar de tantos espacios como la paginación de nuestra memoria (en este caso de 6 en 6), buscar si ése espacio está libre y meter allí y en los 5 espacios siguientes el proceso, claro que hay que cuidar no ocupar espacios de más.


public void meterPaginada(Proceso proceso)
{
  int espacios=0;
  for(int i=0;i<memoria.length;i++)
  {
    if(memoria[i]==null & espacios<proceso.espacio)
    {
      for(j=0;j<6;j++)
      {
        if(espacios<proceso.espacio)
        {
          memoria[i+j]=proceso;
          espacios++;
        }
      }
    }
  }
}

Y para sacar los procesos de la memoria, o sea cuando se terminaron de ejecutar ése proceso, es lo mismo para ambos métodos, sólo buscamos por toda la memoria el proceso que vamos a sacar, y cuando lo encontremos (en todos los espacios que ocupa) ponemos es espacio como null.

public void sacar(Proceso proceso)
{
  for(int i=0;i<memoria.lenght;i++)
  {
    if(memoria[i]==proceso)
    {
      memoria[i]=null;
    }
  }
}

Hasta aquí sería todo lo necesario para construir el programa, ¿Cuándo usar las funciones? pues cuando chequen que procesos se van meter a la cola usen primero el que checa si cabe o no; si cabe usen el de meter en la memoria y también lo meten en la cola. Y cando un proceso pase a ejecución y termine (solo hasta que termine) usan el de sacar y también lo sacan de la cola. Recuerden que deben hacer su método para que les imprima el estado de la memoria.

Vale, espero y lo entiendan ya que me lo chuté en 23 minutos de la media noche.
Nota, yo no usé el de FCFS para éste ejercicio, usé el RR pero es más complejo de explicar y ya tenía éste escrito, si en algo me salté (espero que no) para que funcione ya chéquenle ustedes...

SALUDOS

1 comentario:

  1. algo que simule una máquina virtual, que vaya leyendo código intermedio y vaya reservando memoria para el programa eso sería genial

    ResponderEliminar

Perfil Google+