1. Introducción - Departamento de Computación

HA
C LU C E
UNIVERSIDAD DE A CORUÑA
FACULTAD DE INFORMÁTICA
DEPARTAMENTO DE COMPUTACIÓN
Práctica Obligatoria
Tecnologı́a de la Programación
Ingenierı́a Técnica en Informática de Gestión. Curso 2005/2006
1.
Introducción
Se desea gestionar la ejecución de procesos en un supercomputador para los que se seguirá el
orden establecido por una cola de prioridades. Los procesos que llegan a esta cola tienen una
prioridad asignada y un tiempo de entrada en el sistema.
En este sistema tendrán prioridad los procesos de menor tamaño. De este modo, la prioridad
se determina como el resultado de la división entera entre el tamaño del ejecutable y 1000, y los
procesos se mantienen ordenados de modo creciente según este cociente. Ası́, siempre se ejecuta el
proceso menos reciente de mayor prioridad (i.e., menor tamaño). En circunstancias normales, los
procesos se ejecutan cada 5 milisegundos. Sin embargo, es posible que la ejecución de un proceso
se retrase más de 20 milisegundos debido a que se están ejecutando otros procesos. En este caso su
nivel de prioridad aumenta.
Para resolver el problema será necesario implementar una cola de prioridad como una lista de
colas, ambas estructuras, lista y colas, implementadas mediante arrays1 :
1. Una lista ordenada para mantener las prioridades de los procesos que están a la espera.
2. Varias colas, una por nivel de prioridad, para mantener las procesos en espera.
La figura 1 muestra un ejemplo de estas estructuras y sus interrelaciones para formar, una vez
unidas, una cola de prioridad. Como se puede observar, la cola de prioridades mantendrá tantas
colas como prioridades vayan apareciendo.
Figura 1: Cola de prioridades
1 Se
suponen de tamaño suficiente para evitar problemas de memoria.
1
2.
Interfaz
La resolución del problema requiere la construcción de las siguientes clases:
Una clase Proceso.java que representa los procesos almacenados en la cola y cuya interfaz
es la siguiente:
public class Proceso {
private int tTiempo;
// tiempo de entrada en el sistema
private String tIdProceso; // identificador del proceso
private int tTamano;
// tama~
no del ejecutable correspondiente al proceso
// Inicializa el atributo tTiempo con el valor tiempo
public void establecerTiempo(int tiempo);
// Inicializa el atributo tIdProceso con el valor idProceso
public void establecerIdProceso(String idProceso);
// Inicializa el atributo tTamano con el valor tamano
public void establecerTamano(int tamano);
// Devuelve el valor del atributo tTiempo
public int obtenerTiempo();
// Devuelve el identificador del proceso
public String obtenerIdProceso();
// Devuelve el tama~
no del proceso
public int obtenerTamano();
}
Una clase Cola.java que mantiene los procesos con una misma prioridad. Esta clase presenta
los siguientes métodos y atributos:
// Almacena la posición del último elemento ocupado de la cola.
// Si la cola está vacı́a, este atributo toma el valor -1
private int ultimo;
// Procesos almacenados en la cola
private Proceso ColaProcesos[];
// Constructor
// Crea una Cola vacı́a
public Cola();
// Determina si la cola está vacı́a
public boolean esvacia();
// Inserta un objeto Proceso en la cola, inicializando su tiempo de entrada
public void insertar(Proceso);
// Devuelve el contenido del elemento que se encuentra al frente de la cola.
// Si la operación no se puede realizar devuelve null
public Proceso frente();
2
// Elimina el elemento que está al frente de la cola y devuelve verdadero si
// se ha podido realizar la operación, falso en caso contrario
public boolean borrar();
Una clase ListaOrdenada.java que mantiene las distintas prioridades de los procesos que se
encuentran en el sistema. Esta clase presenta los siguientes métodos y atributos:
// Almacena la posición del último elemento ocupado de la lista.
// Si la lista está vacı́a, este atributo toma el valor -1
private int ultimo;
// Constructor
// Crea una lista vacı́a
public ListaOrdenada();
// Determina si la lista está vacı́a
public boolean esvacia();
// Devuelve el objeto NodoOrdenado que se encuentra en la posición dada
public NodoOrdenado obtener(int posicion);
// Actualiza el contenido del elemento situado en la posición dada
public void actualiza(int posicion, Cola cola);
// Inserta un objeto NodoOrdenado en la lista, inicializando su cola de procesos
public void insertar(int prioridad);
// Elimina un objeto NodoOrdenado de la posición dada de la lista
public void borrar(int posicion);
// Devuelve la posición del elemento de la lista que tiene la prioridad dada
// Devuelve -1 si no existe en la lista dicho elemento
public int buscardato(int prioridad);
Esta clase emplea como dato otra clase denominada NodoOrdenado, que también ha de ser
desarrollada y cuya interfaz es la siguiente:
public class NodoOrdenado {
private int prioridad; // prioridad del nodo
private Cola cola;
// cola de procesos con la prioridad del nodo
// Almacena una prioridad en el nodo
public void insertarPrioridad(int prioridad);
// Devuelve el valor de la prioridad del nodo
public int obtenerPrioridad();
// Devuelve la cola de procesos asociada al nodo
public Cola obtenerCola();
}
Una clase ColaPrioridad.java que mantiene la lista de colas de procesos del sistema. Utiliza
las clases Cola.java y ListaOrdenada.java para implementar un TAD Cola de Prioridad.
Se considerarán los métodos siguientes:
3
// Constructor
// Crea una Cola de Prioridad vacı́a
public ColaPrioridad();
// Determina si la Cola de prioridad está vacı́a
public boolean esvacia();
// Inserta un proceso en la Cola de prioridad con la prioridad dada
public void insertar(Proceso proceso, int prioridad);
// Elimina el primer proceso de la Cola de prioridad.
// Devuelve verdadero si se ha podido realizar la operación, falso en caso contrario
public boolean borrar();
// Devuelve la información del proceso de máxima prioridad (primer elemento
// de la Cola de prioridad). Si la operación no se puede realizar devuelve null
public NodoOrdenado frente();
//
//
//
//
//
//
Mueve a la cola de siguiente prioridad (de entre las existentes en ese momento)
los procesos con tiempo de espera de más de 20 milisegundos con respecto al
parámetro tiempo, que es el tiempo actual.
Al mover un proceso se reinicia su tiempo de entrada tTiempo al tiempo actual,
lo que equivale a reiniciar su tiempo de espera a cero, y se muestra el mensaje
siguiente:
Aumentando prioridad proceso ...<IDProceso><AntiguaPrioridad><NuevaPrioridad>
public void reasignaPrioridad(int tiempo);
Clase Prueba.java que simulará la entrada de procesos en el sistema.
2.1.
Detalles sobre la implementación
Para la implementación de las distintas estructuras comentadas (Cola, Lista ordenada y Cola
de prioridad) se utilizarán arrays.
La simulación de funcionamiento del sistema se hará de acuerdo a la siguiente secuencia de
ejecución:
La secuencia de ejecución del bloque principal de esta clase es la siguiente:
1. Entrada de los procesos en el sistema. El conjunto de procesos que se van a ejecutar en
el sistema se introduce en una cola de entrada 2 .
2. Inicializar a cero un contador de tiempo (cada iteración del bucle se corresponde con un
milisengundo).
3. Repetir hasta que no haya más elementos en la cola de prioridad y no haya más elementos
en la cola de entrada.
• Incrementar contador de tiempo y mostrarlo
• Repetir mientras haya procesos en la cola de entrada con tiempo de entrada en sistema
igual al tiempo actual
◦ Recuperar el primer proceso de la cola de entrada e insertarlo en la cola de
prioridad de acuerdo a la prioridad del proceso.
2 Este
método se proporciona al alumno con la clase Prueba.java
4
◦ Imprimir un mensaje de acuerdo al formato siguiente:
Inicializando ejecución de proceso ...<IDProceso><Prioridad><TEntradaSistema>
• Si han transcurrido 5 milisegundos desde que se inició la última ejecución de un
proceso, ordenar la ejecución del elemento de máxima prioridad eliminándolo de la
cola, y mostrar un mensaje con el formato siguiente:
Ejecutando proceso...<IDProceso><Prioridad><TEntradaSistema>
• Si existe algún elemento de alguna de las colas de la cola de prioridad que tenga
un retraso de más de 20 milisegundos, eliminarlo de la cola, aumentar su prioridad,
cambiar su tiempo de entrada en el sistema al tiempo actual e insertarlo de nuevo
en la cola de prioridad.
3.
Objetivos
Dada la descripción previa de la estructura de las clases Cola, ListaOrdenada, NodoOrdenado
y ColaPrioridad se pide:
1. Realizar la especificación en JML de dichas clases (excepto para la clase NodoOrdenado y
Prueba). Para ello, se especificarán las pre y postcondiciones de cada uno de los métodos y
todas las invariantes de clase (instance invariant) o restricciones (constraint) que sean
necesarias. Cada una de las especificaciones incluidas en todos los métodos deberán estar claramente comentadas. Para ello se emplearán los sı́mbolos de comentarios de JML: (* comentario
*). La especificación JML se realizará en un fichero independiente de la clase. Estos ficheros
se llamarán Cola.jml, ListaOrdenada.jml y ColaPrioridad.jml respectivamente.
2. Construir las clases Cola, ListaOrdenada, NodoOrdenado y ColaPrioridad con todos los
métodos descritos en el apartado interfaz mencionado previamente.
4.
Normas y entrega de la práctica
La práctica se realizará en grupos de una o dos personas, siendo preferible esto último. El
desarrollo normal implica una supervisión más o menos continua durante las clases de laboratorio.
La práctica es obligatoria y, por tanto, aprobarla es imprescindible para aprobar la asignatura. La
entrega se realizará utilizando el sistema habitual de buzón de prácticas. La fecha lı́mite de entrega
es el Miércoles 7 de Junio de 2006, a las 22:00h, quedando inhabilitado el sistema de entrega a partir
de esa hora. Junto con los ficheros de la práctica, se depositará en el buzón de prácticas un archivo
de texto denominado autores.txt con la siguiente información:
TITULO: Practica obligatoria de TP
AUTOR1: _______________________________________ LOGIN: ________ GRUPO:____
AUTOR2: _______________________________________ LOGIN: ________ GRUPO:____
FECHA: __/__/____
La semana siguiente al cierre del buzón de prácticas, figurará en la puerta de los profesores de
prácticas de la asignatura, — despachos 0.11 y Seminario 0.1 planta cero), una hoja de reserva de
hora para efectuar la defensa de la práctica. Dicha defensa es obligatoria para que la práctica sea
puntuable.
5