ALGORITMO DE

REEMPLAZO DE
PÁGINAS OPTIMO
SISTEMAS OPERATIVOS

Jairo González
Israel Ortiz
Carlos Vargas
UNIVERSIDAD TECNICA PARTICULAR DE LOJA
Contenido
ALGORITMO DE PLANIFICACIÓN SJF NO APROPIATIVO....................................................2
1 Resumen...................................................................................................................................2
2 Introducción.............................................................................................................................2
3 Objetivos..................................................................................................................................3
3.1 Objetivo General..............................................................................................................3
3.2 Objetivos Específicos.......................................................................................................3
4 Documentación........................................................................................................................3
5 Diseño.......................................................................................................................................7
6 Pruebas.....................................................................................................................................8
7 Conclusiones............................................................................................................................8

1
 ALGORITMO DE ALGORITMO DE REEMPLAZO DE
PÁGINAS OPTIMO

1 Resumen

El presente informe consiste en desarrollar e implementar un algoritmo de reemplazo

de página, llamado Optimo, para mejorar el entendimiento del algoritmo y hacer que el
proceso de respuesta sea mucho más rápido y así, satisfacer las necesidades del usuario
que la ejecute.
Para la realización de este proyecto fue necesario apoyarse en una metodología de
Interfaces, dado que nos brinda un mayor manejo de información y nos resulta mas
atractiva y simple a la hora de su utilización, pesando siempre en los usuarios.
El portal nos mostrara una interfaz amigable con el usuario, en la cual nos pedirá una
cierta información para poder ejecutarse, luego de eso se nos presentara la información
solicitada.

2 Introducción

Este algoritmo debe de tener el menor índice de fallos de página de todos los algoritmos. En
teoría, este algoritmo debe de reemplazar la página que no va a ser usada por el periodo más largo
de tiempo.

Desafortunadamente, el algoritmo de reemplazo óptimo es fácil en teoría, pero prácticamente

imposible de implementar, dado que requiere conocer a futuro las necesidades del sistema.
Este algoritmo tiene como finalidad retirar la página que vaya a ser referenciada más tarde, por
ejemplo, si hay una página A que será usada dentro de 10000 instrucciones, y una página B que
será usada dentro de 2800 instrucciones, se debería eliminar de la memoria la página A. Como se
puede deducir, para esto el sistema operativo debería ver en cuánto tiempo será usada cada
página en memoria y elegir la que está más distante. El problema de este método es que necesita
conocimiento del futuro, por lo que es imposible su implementación. Es un algoritmo teórico. Se
utiliza a los efectos comparativos con los algoritmos factibles de ser implementados para ver cuál
se aproxima más a éste.

2
3 Objetivos
3.1 Objetivo General

 Desarrollar e implementar el algoritmo de reemplazo de páginas Optimo

3.2 Objetivos Específicos

 Desarrollar un aplicativo, de fácil navegabilidad, y funcional para el usuario final.

 Desarrollar un aplicativo amigable con el usuario.
 Desarrollar la funcionalidad del Diagrama de Gantt.

4 Documentación

Primero debemos crear nuestro proyecto, con sus respectivas clases, incluida una de Prueba.
Además de incorporar un paquete exclusivo para la vista de la Interfaz y eso se puede ver, en la
Fig. 1.

Fig. 1 | Creación de Proyecto y sus Clases

Como podemos observar, en la Fig. 1, se crea una clase principal, llamada OptimoPrueba,
donde se realizará el proceso, con una forma de programación muy básica, con el único propósito
de ver la funcionalidad del programa.

A continuación, dentro de esta clase se declaran las variables a utilizarse, y la lógica del
programa. Como se puede observar en la Fig. 2. Fig. 3.

3
Fig. 2 | Creación de Variables

Fig. 3 | Creación Lógica.

4
Fig. 4 | Creación de Lógica

Fig. 5 | Creación de Lógica.

5
 Fig. 6 | Creación de Creación de Lógica.

Apartir de aquí se realizan unas pruebas para saber si el proyecto esta funcionando de
manera correcta, como se lo puede ver en la Fig. 2.

Fig. 7 | Ejecución del codigo Prueba

6
 Fig. 7 | Ejecución del codigo Prueba

Una vez que sabemos que el programa funciona correctamente, lo pasamos a una forma de
programación mas avanzada, incluyendo métodos, para que estos puedan ser llamados por el
JFrame, que será la forma que tendrá el usuario de ver el programa.

Primero crearemos un Jframe donde interactura el usuario, le agregaremos varios botones,

jtext y TextField que nos ayudaran a que el proyecto se vea mas vistoso.

Dentro del JFrame tenemos la utilización del Boton Aceptar, el cual se nos ayudara a guardar
la configuración de “Cantidad de Marco de Pagina” y “Numero de Paginas”. Este Boton, se une con
el método IngresarDatos en la línea 300, como se ve en la Fig. 2 y la Fig. 2

Fig. 8 | Codigo BtnAceptar

Fig. 9 | Codigo Método IngresarDatos

Dentro del JFrame, también tenemos la utilización del Boton Agregar, el cual se nos ayudara a
guardar los valores de “Valor de cada Pagina”. Este Boton, deber ser utilizado por cada iteración
que realice el programa, además se une con el método AgregarDatos en la línea 256, como se ve
en la Fig. 2 y la Fig. 2

7
 Fig. 10 | Codigo BtnAgregar

Fig. 11 | Codigo Método AgregarDatos

Fig. 12 | Codigo Método AgregarDatos

Adicionalmente, el JFrame cuenta con el Boton Mostrar, el cual nos servirá para presentar los
datos que se obtuvieron gracias a la lógica que se realiza en AgregarDatos, en el TextField. Asi se
muestra el codigo de la Fig. 2.

8
 Fig. 13 | Codigo BtnMostrar

Usamos append en las líneas 272, 274, 276, 279, 282, 284, 286 y 288 para que los datos se
vayan mostrando en el TextField, además se usa el setEnabled(false) para que los botones se
bloqueen en el momento de darle al Boton.

Y para finalizar se crearon dos botones mas, uno para recrear una nueva representación del
algoritmo y otro para finalizar el programa.

El Boton Nuevo, gracias al setText limpiamos los datos que estan ingresados en los Jtext y los
datos que aparecieron en el TextField. Ademas utilizamos el setEnabled(true) para habilitar los
botones que habíamos bloqueado con aterioridad. Esto lo podemos ver en la Fig. 2

Fig. 14 | Codigo BtnNuevo

El Boton Salir simplemente cierra el programa, gracias a un método que trae java por defecto,
el cual es dispose(). Esto se ve en la Fig.2.

Fig. 15 | Codigo BtnSalir

9
5 Diseño

Fig. 16 | Formulario creado.

6 Pruebas

10
Fig. 17 | Prueba Formulario Final

11