Administraci N De Memoria

Administración de memoria
Esta es la clase GestionMemoria mencionada. A la hora de experimentar, el último método, el main(String[] args), es en el que se pueden manipular primitivas como destruyeProceso o creaProceso. Para cambiar el tipo de ajuste, sólo hay que descomentar y comentar las líneas de código en la función creaProceso.
import java.util.LinkedList;
import java.util.List;
 public class GestionMemoria {
       // //////////////////////////////////////////////////////////////
       // IMPLEMENTACIÓN DE UNIDAD DE GESTIÓN DE MEMORIA EN JAVA ///////
       // Por Juan Carlos Roldán Salvador //////////////////////////////
       // Desarrollado en JavaSE-1.7 ///////////////////////////////////
       // Modificado por última vez el 3/12/2012 ///////////////////////
       ////////////////////////////////////////////////////////////////
       //
       // Esta es una implementación funcional de los métodos de primer,
       // siguiente, mejor y peor ajuste.
       // En ella se supone una memoria de 32 kB y una gestión mediante
       // listas de control con ticks de 1 kB. Cada uno de los bloques de       // la lista de control es una array de int de 4 valores, que son:
       // 0: Estado (Un valor de 0 significa libre, un valor de 1 ocupado)
       // 1: Dirección inicial del bloque
       // 2: Tamaño (En ticks)
       // 3: Pid del proceso al que está asignado
       //
       // Para cambiar el tipo de ajuste que se aplica solo hay que
       // comentar/descomentar líneas de código de la función creaProceso.
       // Se puede cambiar el tamaño del mapa de memoria de 32 acualquier
       // otro.
       // Para ver el estado de la memoria por pantalla se usa la función
       // imprimeMemoria(). Para crear y destruir procesos se usan las
       // funciones creaProceso y destruyeProceso, respectivamente.
       // En la función main (Al final de la clase) hay un ejemplo, con la
       // creación y destrucción de varios procesos.       public static final int LONGITUD_MEMORIA = 32;
       public static List listaControl;
       public static int[] memoria;
       public static int ultimoPid;
 
       /**
        * Inicia los atributos necesarios para el funcionamiento de la memoria.
        *
        */
       private static void inicializaMemoria() {
             listaControl = new LinkedList();
             memoria = new int[LONGITUD_MEMORIA];             ultimoPid = 0;
             // Añade una primera entrada a la lista de control, un hueco con el
             // tamaño de la memoria completa:
             int[] hueco = { 0, 0, LONGITUD_MEMORIA, 0 };
             listaControl.add(hueco);
       }
 
       /**
        * Simula la escritura de datos en la memoria. Guarda los datos en una
        * array, a modo de mapa de bits.
        *
       * @param direccion
        *            - En ticks, posición en que empieza la escritura.
        * @param tamanyo
        *            - Ticks que se extiende la escritura.
        * @param dato
        *            - Marca que se pondrá en la memoria, que en un caso real sería
        *            parte del proceso. Por ejemplo, '1' para memoria ocupada y '0'
        *            para memoria vacía.        */
       private static void escribeMemoria(int direccion, int tamanyo, int dato) {
             //Escribe el dato 'dato' en las posiciones pertinentes:
             for (int i = 0; i < tamanyo; i++) {
                    memoria[direccion + i] = dato;
                    // Aquí se puede incluir un delay para simular el acceso a memoria:
                    /*
                     * try {Thread.sleep(3); } catch (InterruptedException e) {
                     * e.printStackTrace(); }
                     */
             }
       }
 
       /**
        * Asigna un bloque de memoria a un nuevo proceso.
        *
        * @param pid
        *            - Identificador numérico del proceso que se va a crear. El que
        *            la...

Leer documento completo

Regístrate para leer el documento completo.