Algoritmos de Planificación del Procesador con P.O.O.
 

1. Introducción
2. Objetivo del Caso de Estudio
3. Descripción del Problema Planteado
4. Descripción de los Algoritmos Utilizados
5. Programa Desarrollado
6. Datos y Ejecuciones
7. Resultados y Conclusiones
8. Fin

Introducción

Una de las muchas y muy variadas posibles aplicaciones de la P.O.O. (programación orientada a objetos) [2, Joyanes] está en el desarrollo de algoritmos que implementen estrategias de administración de recursos por parte del Sistema Operativo.

Como parte de las estrategias antes mencionadas, podemos considerar las de administración o asignación del procesador, es decir aquéllas según las cuales los S. O. seleccionan a cuál de los procesos listos para ser ejecutados en ejecución concurrente, le asignarán el procesador en un momento dado, es decir, a qué proceso darán la posibilidad de utilizar la CPU para ejecutar sus propias instrucciones; a esta decisión también se la conoce como despacho del proceso [23, Tanenbaum] y [7, Deitel].

Inicio:   Fin:

Objetivo del Caso de Estudio

El objetivo del presente caso consistió en la realización de un programa en Turbo C++ [12, Borland] (Procesos.cpp) que implementara las principales estrategias de asignación del procesador a procesos en ejecución concurrente.

Asimismo también se estableció como objetivo del caso la inclusión en el programa de la posibilidad de grabar un archivo de log histórico (Procesos.txt), que incorporara para cada simulación efectuada, un resumen de las principales conclusiones referidas a las estrategias consideradas, lo que permite su análisis y discusión posterior.

Inicio:   Fin:

Descripción del Problema Planteado

Una descripción detallada del problema planteado puede consultarse en el Capítulo “Procesos y Administración del Procesador”, siendo especialmente pertinentes los temas relacionados con planificación del procesador.

Inicio:   Fin:

Descripción de los Algoritmos Utilizados

Al igual que en el apartado anterior, una descripción detallada de las estrategias de planificación y de los algoritmos para implementarlas se puede consultar en el Capítulo “Procesos y Administración del Procesador”.

Inicio:   Fin:

Programa Desarrollado

El programa desarrollado (Procesos.cpp), codificado en Turbo C++ utilizando metodología de orientación a objetos ( [2, Joyanes], [1, Joyanes], [3, Joyanes, Rodríquez y Fernández] y [15, Joyanes y Zahonero]), implementa cuatro estrategias de planificación del procesador, a saber:

• FIFO: Primero en llegar, primero en ser despachado, es decir que los procesos son atendidos según su orden en la lista de procesos listos y una vez que reciben el procesador lo utilizan hasta que finalizan o hasta que se presenta una petición de entrada / salida requerida por el propio programa.
• RR: Round Robin: Los procesos son atendidos según su orden en la lista de procesos listos, pero disponen de un tiempo limitado (cuantum) del procesador, es decir que pueden ser interrumpidos por requerimientos propios de entrada / salida o por haber agotado su tiempo de procesador; obviamente que la otra causa de interrupción es la finalización del proceso.
• HRN: Los procesos son atendidos según su prioridad en la lista de procesos listos; la prioridad depende de la relación de respuesta: (TE + TS) / TS, donde TE = Tiempo de Espera y TS = Tiempo de Servicio; es decir que un proceso tiene mayor probabilidad de acceder a la cpu si ha hecho poco uso de ella; el tiempo de espera más el tiempo de servicio es el tiempo total que lleva el proceso en el sistema, es decir la cantidad de ciclos de control que se han contabilizado en la simulación, en tanto que el tiempo de servicio es el número de ciclos de control que el proceso ha utilizado; en este caso el proceso que dispone de la cpu puede ser interrumpido porque finaliza o porque requiere una operación de entrada / salida.
• RNM: Los procesos son atendidos según su nivel en la lista de procesos listos, la cual se divide en subcolas, cada una de ellas asociada a un nivel determinado, pero los procesos disponen de un tiempo limitado (cuantum) del procesador; si son interrumpidos por entrada / salida permanecen en la subcola del nivel donde están, pero si son interrumpidos por tiempo pasan a un nivel mayor, que tiene menor preferencia, que es atendido cuando ya no hay procesos listos en los niveles inferiores; de allí el nombre de Retroalimentación de Niveles Múltiples; de lo antes mencionado se desprende que un proceso puede ser interrumpido porque finaliza, porque agota su tiempo de procesador o porque requiere una operación de entrada / salida. En la implementación efectuada los niveles identificados con un número menor son los que tienen de hecho mayor prioridad y los identificados con un número mayor son los que reciben menor prioridad.

/* Simulación de estrategias de asignación del procesador */
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <iostream.h>
#include <io.h>
FILE *textfile; /* Pointer al archivo usado */
// char regis[70]; /* Registro del archivo usado (para lectura) */
class Proc{
public:
/* identif: identificación del proceso */
char identif;
/* fin: estado de finalización del proceso */
/* 0: listo para ejecutar */
/* 1: interrumpido p/ entrada / salida */
/* 3: interrumpido p/ tiempo */
/* 2: terminado */
int fin;
/* cuenta: total de ciclos de control asignados al proceso */
int cuenta;
/* pri: prioridad del proceso */
int pri;
/* nivel: identificación de la sub-cola donde est el proceso */
int nivel;
Proc()
{ identif = 0; fin = 0; cuenta = 0; pri = 0; nivel = 0;}; // Inicialización de valores.
};
class procesos{
public:
int cc; // Número de ciclos de control.
int np; // Número de procesos.
char auxiden; // Variable auxiliar.
int auxfin; // Variable auxiliar.
int auxcuenta; // Variable auxiliar.
int auxpri; // Variable auxiliar.
int auxnivel; // Variable auxiliar.
int cambio; // Variable auxiliar.
Proc p[50]; // Vector (lista) de procesos.
void inicio(); // Acciones iniciales.
void introducir_datos(); // Carga de identificación de procesos.
void mostrar(); // Mostrar lista de procesos.
void fifo(); // Simulación según estrategia FIFO.
void rrobin(); // Simulación según estrategia RR (Round Robin).
void hrn(); // Simulación según estrategia HRN (Relación de Respuesta Máxima).
void rnm(); // Simulación según estrategia RNM (Retroalimentación de Niveles Múltiples).
void final(); // Acciones finales.
};
void procesos::inicio(){
cout << ”*****************************************************”;
cout << ”\n”;
cout << ”*Estrategias de asignación del procesador a procesos*”;
cout << ”\n”;
cout << ”*en ejecución concurrente. *”;
cout << ”\n”;
cout << ”*****************************************************”;
cout << ”\n”;
cout << ”\n”;
cout << ”Introduzca el número de ciclos de control de la simulación.”;
cout << ”\n”;
cout << ”(Se sugiere entre 30 y 40 por cada 10 procesos): ”;
cin >> cc;
cout << ”\n”;
cout << ”Introduzca el número de procesos de la simulación.”;
cout << ”\n”;
cout << ”(El máximo permitido es 50): ”;
cin >> np;
cout << ”\n”;
if (np > 50)
{np = 50;
cout << ”El número de procesos se ha limitado a 50. \n”;
cout << ”\n”;
}
/* Apertura del archivo usado para grabación */
cout << ”Apertura del archivo resumen ’PROCESOS.TXT’ para grabación. \n”;
cout << ”(Carpeta BIN de la carpeta TC). \n”;
cout << ”\n”;
if ((textfile = fopen(”procesos.txt”, ”a”)) == NULL)
{printf(”Error de apertura para grabación en el archivo ’procesos.txt’ \n”);
exit (0);
}
}
void procesos::introducir_datos(){
char opc;
cout << ”\nSi desea introducir manualmente la identificación de los procesos \n”;
cout << ”tipee: ’s’, de lo contrario: ’n’ y el sistema asumirá las identificaciones. \n”;
cin >> opc;
if (opc == ’s’) {
for (register int i=0; i<np; i++)
{cout << ”Introduzca la identificación del proceso p[” <<i << ”]: ”;
cin >> p[i].identif;
}
}
else {
p[0].identif = ’a’;
p[1].identif = ’b’;
p[2].identif = ’c’;
p[3].identif = ’d’;
p[4].identif = ’e’;
p[5].identif = ’f ’;
p[6].identif = ’g’;
p[7].identif = ’h’;
p[8].identif = ’i’;
p[9].identif = ’j’;
p[10].identif = ’k’;
p[11].identif = ’l’;
p[12].identif = ’m’;
p[13].identif = ’n’;
p[14].identif = ’o’;
p[15].identif = ’p’;
p[16].identif = ’q’;
p[17].identif = ’r’;
p[18].identif = ’s’;
p[19].identif = ’t’;
p[20].identif = ’u’;
p[21].identif = ’v’;
p[22].identif = ’w’;
p[23].identif = ’x’;
p[24].identif = ’y’;
p[25].identif = ’z’;
p[26].identif = ’1’;
p[27].identif = ’2’;
p[28].identif = ’3’;
p[29].identif = ’4’;
p[30].identif = ’5’;
p[31].identif = ’6’;
p[32].identif = ’7’;
p[33].identif = ’8’;
p[34].identif = ’9’;
p[35].identif = ’A’;
p[36].identif = ’B’;
p[37].identif = ’C’;
p[38].identif = ’D’;
p[39].identif = ’E’;
p[40].identif = ’F’;
p[41].identif = ’G’;
p[42].identif = ’H’;
p[43].identif = ’I’;
p[44].identif = ’J’;
p[45].identif = ’K’;
p[46].identif = ’L’;
p[47].identif = ’M’;
p[48].identif = ’N’;
p[49].identif = ’O’;
}
for (register int i=0; i<np; i++)
{p[i].fin = 0;
p[i].cuenta = 0;
p[i].pri = 0;
p[i].nivel = 0;
}
}
void procesos::mostrar(){
printf(”\n”);
cout << ”Listado de procesos:” <<”\n”;
cout << ”********************” <<”\n”;
cout << ”Estado: 0 -> Listo para ejecutar.” <<”\n”;
cout << ”Estado: 1 -> Interrumpido en espera de entrada / salida.” <<”\n”;
cout << ”Estado: 2 -> Proceso terminado.” <<”\n”;
cout << ”Estado: 3 -> Interrumpido por tiempo (no aplicable en FIFO ni en HRN).”
<<”\n”;
for (register int i=0; i<np; i++)
{cout << ”Proceso p[” <<i << ”]: ” << p[i].identif<< ” Estado: ”<< p[i].fin<< ”
Ciclos de control utilizados: ”<< p[i].cuenta<< ”\n”;
cout << ”Proceso p[” <<i << ”]: ” << p[i].identif<< ” Prioridad: ”<< p[i].pri<< ”
Nivel: ”<< p[i].nivel;
cout <<”\n”;
}
}
void procesos::fifo(){
auxiden = 0; auxfin = 0; auxcuenta = 0; cambio = 0;
/* Grabación en el archivo usado */
fprintf(textfile, ”%s\n”, ”************************************************************”);
fprintf(textfile, ”%s”, ”Simulación FIFO con ”);
fprintf(textfile, ”%i”, cc);
fprintf(textfile, ”%s\n”, ” ciclos de control.”);
cout <<”\n”;
cout <<”Secuencia de selección de procesos para su ejecución según FIFO:”;
cout <<”\n”;
cout <<”****************************************************************”;
cout <<”\n”;
cout <<”Los procesos son atendidos según su orden en la lista de procesos listos:”;
cout <<”\n” <<”\n”;
for (register int j=0; j<cc; j++) // ***Realiza ’cc’ ciclos de control***
{auxfin = 0;
for (register int m=0; m<np; m++)
{auxfin = auxfin + p[m].fin;}
if (auxfin == (np * 2))
{
cout <<”\n”<< ”Todos los procesos han finalizado en ”<< j << ” ciclos de control.\n”;
/* Grabación en el archivo usado */
fprintf(textfile, ”%s”, ”Todos los procesos han finalizado en ”);
fprintf(textfile, ”%i”, j);
fprintf(textfile, ”%s\n”, ” ciclos de control.”);
j = cc;
auxfin = getch();
}
for (register int i=0; i<np; i++)
{if (p[i].fin == 0)
{
cout <<”Procesador asignado al proceso: ”<< p[i].identif;
cout <<”\n”;
p[i].cuenta = p[i].cuenta + 1;
p[i].fin = int(random(3)); // Determina próximo estado del proceso.
// cout <<”\n” <<p[i].identif <<p[i].fin <<”\n”;
if (p[i].fin == 1)
cout <<”Proceso ”’ <<p[i].identif <<”’ interrumpido por entrada / salida. ”<< ”\n”;
else {if (p[i].fin == 2)
cout <<”Proceso ”’ <<p[i].identif <<”’ finalizado. ”<< ”\n”;
}
if (p[i].fin > 0)
{ // Intercambio de contexto.
cambio = cambio + 1;
auxiden = p[i].identif;
auxfin = p[i].fin;
auxcuenta = p[i].cuenta;
for (register int k=i; k<(np - 1); k++)
{p[k].identif = p[k+1].identif;
p[k].fin = p[k+1].fin;
p[k].cuenta = p[k+1].cuenta;
}
p[(np - 1)].identif = auxiden;
p[(np - 1)].fin = auxfin;
p[(np - 1)].cuenta = auxcuenta;
}
i = np;
auxfin = getch();
}
for (register int k=0; k<np; k++) // Determina si continúa la espera por entrada /
salida.
{if (p[k].fin == 1) p[k].fin = int (random (2));
}
}
}
cout <<”\n”<< ”***Se han producido ”<< cambio<< ” cambios de contexto.***”<<
”\n”;
/* Grabación en el archivo usado */
fprintf(textfile, ”%s”, ”Se han simulado ”);
fprintf(textfile, ”%i”, np);
fprintf(textfile, ”%s\n”, ” procesos concurrentes.”);
fprintf(textfile, ”%s”, ”Se han producido ”);
fprintf(textfile, ”%i”, cambio);
fprintf(textfile, ”%s\n”, ” cambios de contexto.”);
auxfin = getch();
}
void procesos::rrobin(){
auxiden = 0; auxfin = 0; auxcuenta = 0; cambio = 0;
/* Grabación en el archivo usado */
fprintf(textfile, ”%s\n”, ”************************************************************”);
fprintf(textfile, ”%s”, ”Simulación RR - Round Robin con ”);
fprintf(textfile, ”%i”, cc);
fprintf(textfile, ”%s\n”, ” ciclos de control.”);
cout <<”\n”;
cout <<”Secuencia de selección de procesos para su ejecución según RR - Round Robin:”;
cout <<”\n”;
cout <<”****************************************************************************”;
cout <<”\n”;
cout <<”Los procesos son atendidos según su orden en la lista de procesos listos,\n”;
cout <<”pero disponen de un tiempo limitado (cuantum) del procesador:”;
cout <<”\n” <<”\n”;
for (register int j=0; j<cc; j++) // ***Realiza ’cc’ ciclos de control***
{auxfin = 0;
for (register int m=0; m<np; m++)
{if (p[m].fin != 2)
{auxfin = 1;
m = np;
}
}
if (auxfin == 0)
{
cout <<”\n”<< ”Todos los procesos han finalizado en ”<< j << ” ciclos de control.\n”;
/* Grabación en el archivo usado */
fprintf(textfile, ”%s”, ”Todos los procesos han finalizado en ”);
fprintf(textfile, ”%i”, j);
fprintf(textfile, ”%s\n”, ” ciclos de control.”);
j = cc;
auxfin = getch();
}
for (register int i=0; i<np; i++)
{if (p[i].fin == 0)
{
cout <<”Procesador asignado al proceso: ”<< p[i].identif;
cout <<”\n”;
p[i].cuenta = p[i].cuenta + 1;
p[i].fin = int(random(4)); // Determina próximo estado del proceso.
// cout <<”\n” <<p[i].identif <<p[i].fin <<”\n”;
if (p[i].fin == 0) p[i].fin = 3;
if (p[i].fin == 1)
cout <<”Proceso ”’ <<p[i].identif <<”’ interrumpido por entrada / salida. ”<< ”\n”;
else {if (p[i].fin == 2)
cout <<”Proceso ”’ <<p[i].identif <<”’ finalizado. ”<< ”\n”;
else {if (p[i].fin == 3)
cout <<”Proceso ”’ <<p[i].identif <<”’ interrumpido por tiempo. ”<< ”\n”;
}
}
if (p[i].fin >= 0)
{ // Intercambio de contexto.
cambio = cambio + 1;
auxiden = p[i].identif;
auxfin = p[i].fin;
auxcuenta = p[i].cuenta;
for (register int k=i; k<(np - 1); k++)
{p[k].identif = p[k+1].identif;
p[k].fin = p[k+1].fin;
p[k].cuenta = p[k+1].cuenta;
}
p[(np - 1)].identif = auxiden;
p[(np - 1)].fin = auxfin;
p[(np - 1)].cuenta = auxcuenta;
}
i = np;
auxfin = getch();
}
for (register int k=0; k<np; k++) // Determina si continúa la espera por entrada /
salida.
{if (p[k].fin == 1) p[k].fin = int (random (2));
}
for (register int l=0; l<np; l++) // Determina si continúa la espera por tiempo.
{if (p[l].fin == 3)
{auxfin = int (random (4));
if (auxfin == 1) aux…n = 0;
else {if (auxfin == 2) auxfin = 3;}
p[l].fin = auxfin;
}
}
}
}
cout <<”\n”<< ”***Se han producido ”<< cambio<< ” cambios de contexto.***”<<
”\n”;
/* Grabación en el archivo usado */
fprintf(textfile, ”%s”, ”Se han simulado ”);
fprintf(textfile, ”%i”, np);
fprintf(textfile, ”%s\n”, ” procesos concurrentes.”);
fprintf(textfile, ”%s”, ”Se han producido ”);
fprintf(textfile, ”%i”, cambio);
fprintf(textfile, ”%s\n”, ” cambios de contexto.”);
auxfin = getch();
}
void procesos::hrn(){
auxiden = 0; auxfin = 0; auxcuenta = 0; auxpri = 0; cambio = 0;
/* Grabación en el archivo usado */
fprintf(textfile, ”%s\n”, ”************************************************************”);
fprintf(textfile, ”%s”, ”Simulación HRN con ”);
fprintf(textfile, ”%i”, cc);
fprintf(textfile, ”%s\n”, ” ciclos de control.”);
cout <<”\n”;
cout <<”Secuencia de selección de procesos para su ejecución según HRN:”;
cout <<”\n”;
cout <<”***************************************************************”;
cout <<”\n”;
cout <<”Los procesos son atendidos según su prioridad en la lista de procesos listos;\n”;
cout <<”la prioridad depende de la relación de respuesta: (TE + TS) / TS, donde\n”;
cout <<”TE = Tiempo de Espera y TS = Tiempo de Servicio:”;
cout <<”\n” <<”\n”;
for (register int j=0; j<cc; j++) // ***Realiza ’cc’ ciclos de control***
{auxfin = 0;
for (register int m=0; m<np; m++)
{auxfin = auxfin + p[m].fin;}
if (auxfin == (np * 2))
{
cout <<”\n”<< ”Todos los procesos han finalizado en ”<< j << ” ciclos de control.\n”;
/* Grabación en el archivo usado */
fprintf(textfile, ”%s”, ”Todos los procesos han finalizado en ”);
fprintf(textfile, ”%i”, j);
fprintf(textfile, ”%s\n”, ” ciclos de control.”);
j = cc;
auxfin = getch();
}
if (j == 0)
{for (register int z=0; z<np; z++)
{p[z].cuenta = 1;}
}
if (j < cc)
{
for (register int l=0; l<np; l++)
{p[l].pri = (j / p[l].cuenta);
}
}
if (auxpri == 1)
{
for (register int s=0; s<np; s++)
{for (register int t=s; t<(np - 1); t++)
{if (p[t+1].pri > p[t].pri)
{auxiden = p[t].identif;
auxfin = p[t].fin;
auxcuenta = p[t].cuenta;
auxpri = p[t].pri;
p[t].identif = p[t+1].identif;
p[t].fin = p[t+1].fin;
p[t].cuenta = p[t+1].cuenta;
p[t].pri = p[t+1].pri;
p[t+1].identif = auxiden;
p[t+1].fin = auxfin;
p[t+1].cuenta = auxcuenta;
p[t+1].pri = auxpri;
}
}
}
}
for (register int i=0; i<np; i++)
{if (p[i].fin == 0)
{auxpri = 0;
cout <<”Procesador asignado al proceso: ”<< p[i].identif;
cout <<”\n”;
p[i].cuenta = p[i].cuenta + 1;
p[i].fin = int(random(3)); // Determina próximo estado del proceso.
// cout <<”\n” <<p[i].identif <<p[i].fin <<”\n”;
if (p[i].fin == 1)
cout <<”Proceso ”’ <<p[i].identif <<”’ interrumpido por entrada / salida. ”<< ”\n”;
else {if (p[i].fin == 2)
cout <<”Proceso ”’ <<p[i].identif <<”’ finalizado. ”<< ”\n”;
}
if (p[i].fin > 0)
{ // Intercambio de contexto.
cambio = cambio + 1;
auxiden = p[i].identif;
auxfin = p[i].fin;
auxcuenta = p[i].cuenta;
auxpri = p[i].pri;
for (register int k=i; k<(np - 1); k++)
{p[k].identif = p[k+1].identif;
p[k].fin = p[k+1].fin;
p[k].cuenta = p[k+1].cuenta;
p[k].pri = p[k+1].pri;
}
p[(np - 1)].identif = auxiden;
p[(np - 1)].fin = auxfin;
p[(np - 1)].cuenta = auxcuenta;
p[(np - 1)].pri = auxpri;
auxpri = 1; // Indica que hubo intercambio de contexto y debe reordenarse la lista de
procesos según prioridades.
}
i = np;
auxfin = getch();
}
for (register int k=0; k<np; k++) // Determina si continúa la espera por entrada /
salida.
{if (p[k].fin == 1) p[k].fin = int (random (2));
}
}
}
for (register int y=0; y<np; y++)
{p[y].cuenta = p[y].cuenta - 1;}
cout <<”\n”<< ”***Se han producido ”<< cambio<< ” cambios de contexto.***”<<
”\n”;
/* Grabación en el archivo usado */
fprintf(textfile, ”%s”, ”Se han simulado ”);
fprintf(textfile, ”%i”, np);
fprintf(textfile, ”%s\n”, ” procesos concurrentes.”);
fprintf(textfile, ”%s”, ”Se han producido ”);
fprintf(textfile, ”%i”, cambio);
fprintf(textfile, ”%s\n”, ” cambios de contexto.”);
auxfin = getch();
}
void procesos::rnm(){
auxiden = 0; auxfin = 0; auxcuenta = 0; auxpri = 0; auxnivel = 0; cambio = 0;
/* Grabación en el archivo usado */
fprintf(textfile, ”%s\n”, ”************************************************************”);
fprintf(textfile, ”%s”, ”Simulación RNM con ”);
fprintf(textfile, ”%i”, cc);
fprintf(textfile, ”%s\n”, ” ciclos de control.”);
cout <<”\n”;
cout <<”Secuencia de selección de procesos para su ejecución según RNM:”;
cout <<”\n”;
cout <<”**************************************************************”;
cout <<”\n”;
cout <<”Los procesos son atendidos según su nivel en la lista de procesos listos;\n”;
cout <<”pero disponen de un tiempo limitado (cuantum) del procesador;\n”;
cout <<”si son interrumpidos por entrada / salida permanecen en la subcola\n”;
cout <<”del nivel donde están, pero si son interrumpidos por tiempo pasan a\n”;
cout <<”un nivel superior, que es atendido cuando ya no hay procesos listos\n”;
cout <<”en los niveles inferiores; de allí el nombre de\n”;
cout <<”Retroalimentación de Niveles Múltiples:”;
cout <<”\n” <<”\n”;
for (register int j=0; j<cc; j++) // ***Realiza ’cc’ ciclos de control***
{auxfin = 0;
for (register int m=0; m<np; m++)
{if (p[m].fin != 2)
{auxfin = 1;
m = np;
}
}
if (auxfin == 0)
{
cout <<”\n”<< ”Todos los procesos han finalizado en ”<< j << ” ciclos de control.\n”;
/* Grabación en el archivo usado */
fprintf(textfile, ”%s”, ”Todos los procesos han finalizado en ”);
fprintf(textfile, ”%i”, j);
fprintf(textfile, ”%s\n”, ” ciclos de control.”);
j = cc;
auxfin = getch();
}
if (auxpri == 1)
{
for (register int s=0; s<np; s++)
{for (register int t=s; t<(np - 1); t++)
{if (p[t+1].nivel < p[t].nivel)
{auxiden = p[t].identif;
auxfin = p[t].fin;
auxcuenta = p[t].cuenta;
auxpri = p[t].pri;
auxnivel = p[t].nivel;
p[t].identif = p[t+1].identif;
p[t].fin = p[t+1].fin;
p[t].cuenta = p[t+1].cuenta;
p[t].pri = p[t+1].pri;
p[t].nivel = p[t+1].nivel;
p[t+1].identif = auxiden;
p[t+1].fin = auxfin;
p[t+1].cuenta = auxcuenta;
p[t+1].pri = auxpri;
p[t+1].nivel = auxnivel;
}
}
}
}
for (register int i=0; i<np; i++)
{if (p[i].fin == 0)
{auxpri = 0;
cout <<”Procesador asignado al proceso: ”<< p[i].identif;
cout <<”\n”;
p[i].cuenta = p[i].cuenta + 1;
p[i].fin = int(random(4)); // Determina próximo estado del proceso.
// cout <<”\n” <<p[i].identif <<p[i].fin <<p[i].nivel <<”\n”;
if (p[i].fin == 0) p[i].fin = 3;
if (p[i].fin == 1)
cout <<”Proceso ”’ <<p[i].identif <<”’ interrumpido por entrada / salida. ”<< ”\n”;
else {if (p[i].fin == 2)
cout <<”Proceso ”’ <<p[i].identif <<”’ finalizado. ”<< ”\n”;
else {if (p[i].fin == 3)
cout <<”Proceso ”’ <<p[i].identif <<”’ interrumpido por tiempo. ”<< ”\n”;
p[i].nivel = p[i].nivel + 1;
}
}
if (p[i].fin > 0)
{ // Intercambio de contexto.
cambio = cambio + 1;
auxiden = p[i].identif;
auxfin = p[i].fin;
auxcuenta = p[i].cuenta;
auxpri = p[i].pri;
auxnivel = p[i].nivel;
for (register int k=i; k<(np - 1); k++)
{p[k].identif = p[k+1].identif;
p[k].fin = p[k+1].fin;
p[k].cuenta = p[k+1].cuenta;
p[k].pri = p[k+1].pri;
p[k].nivel = p[k+1].nivel;
}
p[(np - 1)].identif = auxiden;
p[(np - 1)].fin = auxfin;
p[(np - 1)].cuenta = auxcuenta;
p[(np - 1)].pri = auxpri;
p[(np - 1)].nivel = auxnivel;
auxpri = 1; // Indica que hubo intercambio de contexto y debe reordenarse la lista de
procesos según prioridades.
}
i = np;
auxfin = getch();
}
for (register int k=0; k<np; k++) // Determina si continúa la espera por entrada /
salida.
{if (p[k].fin == 1) p[k].fin = int (random (2));
}
for (register int l=0; l<np; l++) // Determina si continúa la espera por tiempo.
{if (p[l].fin == 3)
{auxfin = int (random (4));
if (auxfin == 1) auxfin = 0;
else {if (auxfin == 2) auxfin = 3;}
p[l].fin = auxfin;
}
}
}
}
cout <<” n n”<< ”***Se han producido ”<< cambio<< ” cambios de contexto.***”<<
”\n”;
/* Grabación en el archivo usado */
fprintf(textfile, ”%s”, ”Se han simulado ”);
fprintf(textfile, ”%i”, np);
fprintf(textfile, ”%s\n”, ” procesos concurrentes.”);
fprintf(textfile, ”%s”, ”Se han producido ”);
fprintf(textfile, ”%i”, cambio);
fprintf(textfile, ”%s\n”, ” cambios de contexto.”);
auxfin = getch();
}
void procesos::final(){
/* Cierre del archivo usado */
cout << ”\nCierre del archivo resumen ’PROCESOS.TXT’.\n”;
cout << ”Se sugiere visualizar su contenido con el Notepad.exe de Windows.\n”;
fclose(textfile);
}
void main(){
/* Variables */
procesos p1;
/* Código */
clrscr();
p1.inicio();
p1.introducir_datos();
p1.mostrar();
p1.fifo();
p1.mostrar();
p1.introducir_datos();
p1.mostrar();
p1.rrobin();
p1.mostrar();
p1.introducir_datos();
p1.mostrar();
p1.hrn();
p1.mostrar();
p1.introducir_datos();
p1.mostrar();
p1.rnm();
p1.mostrar();
p1.final();
getch();
}

Inicio:   Fin:

Datos y Ejecuciones

Los datos esenciales para la simulación de las distintas estrategias se introducen por teclado, siendo opcional el ingreso de la identificación de los procesos, ya que la misma se puede generar automáticamente.

Los datos esenciales antes mencionados son el número de ciclos de control y el número de procesos que intervendrán en la simulación.

Los resultados detallados de las ejecuciones se muestran paso a paso en pantalla y un resumen de los mismos se graba en un archivo de texto (Procesos.txt), que puede ser visualizado con cualquier editor, por ejemplo el Notepad o el Wordpad de Windows.

El contenido del mencionado archivo luego de varias ejecuciones de evaluación es el siguiente:

************************************************************
Simulación FIFO con 3 ciclos de control.
Se han simulado 3 procesos concurrentes.
Se han producido 1 cambios de contexto.
************************************************************
Simulación RR - Round Robin con 3 ciclos de control.
Se han simulado 3 procesos concurrentes.
Se han producido 3 cambios de contexto.
************************************************************
Simulación HRN con 3 ciclos de control.
Se han simulado 3 procesos concurrentes.
Se han producido 2 cambios de contexto.
************************************************************
Simulación RNM con 3 ciclos de control.
Se han simulado 3 procesos concurrentes.
Se han producido 3 cambios de contexto.
************************************************************
Simulación FIFO con 100 ciclos de control.
Todos los procesos han finalizado en 14 ciclos de control.
Se han simulado 5 procesos concurrentes.
Se han producido 10 cambios de contexto.
************************************************************
Simulación RR - Round Robin con 100 ciclos de control.
Todos los procesos han finalizado en 11 ciclos de control.
Se han simulado 5 procesos concurrentes.
Se han producido 11 cambios de contexto.
************************************************************
Simulación HRN con 100 ciclos de control.
Todos los procesos han finalizado en 26 ciclos de control.
Se han simulado 5 procesos concurrentes.
Se han producido 15 cambios de contexto.
************************************************************
Simulación RNM con 100 ciclos de control.
Todos los procesos han finalizado en 10 ciclos de control.
Se han simulado 5 procesos concurrentes.
Se han producido 10 cambios de contexto.
************************************************************
Simulación FIFO con 90 ciclos de control.
Todos los procesos han finalizado en 10 ciclos de control.
Se han simulado 3 procesos concurrentes.
Se han producido 7 cambios de contexto.
************************************************************
Simulación RR - Round Robin con 90 ciclos de control.
Todos los procesos han finalizado en 10 ciclos de control.
Se han simulado 3 procesos concurrentes.
Se han producido 9 cambios de contexto.
************************************************************
Simulación HRN con 90 ciclos de control.
Todos los procesos han finalizado en 22 ciclos de control.
Se han simulado 3 procesos concurrentes.
Se han producido 13 cambios de contexto.
************************************************************
Simulación RNM con 90 ciclos de control.
Todos los procesos han finalizado en 14 ciclos de control.
Se han simulado 3 procesos concurrentes.
Se han producido 14 cambios de contexto.
************************************************************
Simulación FIFO con 90 ciclos de control.
Todos los procesos han finalizado en 15 ciclos de control.
Se han simulado 6 procesos concurrentes.
Se han producido 11 cambios de contexto.
************************************************************
Simulación RR - Round Robin con 90 ciclos de control.
Todos los procesos han finalizado en 32 ciclos de control.
Se han simulado 6 procesos concurrentes.
Se han producido 32 cambios de contexto.
************************************************************
Simulación HRN con 90 ciclos de control.
Todos los procesos han finalizado en 20 ciclos de control.
Se han simulado 6 procesos concurrentes.
Se han producido 13 cambios de contexto.
************************************************************
Simulación RNM con 90 ciclos de control.
Todos los procesos han finalizado en 12 ciclos de control.
Se han simulado 6 procesos concurrentes.
Se han producido 12 cambios de contexto.
************************************************************
Simulación FIFO con 70 ciclos de control.
Todos los procesos han finalizado en 14 ciclos de control.
Se han simulado 5 procesos concurrentes.
Se han producido 10 cambios de contexto.
************************************************************
Simulación RR - Round Robin con 70 ciclos de control.
Todos los procesos han finalizado en 11 ciclos de control.
Se han simulado 5 procesos concurrentes.
Se han producido 11 cambios de contexto.
************************************************************
Simulación HRN con 70 ciclos de control.
Todos los procesos han finalizado en 26 ciclos de control.
Se han simulado 5 procesos concurrentes.
Se han producido 15 cambios de contexto.
************************************************************
Simulación RNM con 70 ciclos de control.
Todos los procesos han finalizado en 10 ciclos de control.
Se han simulado 5 procesos concurrentes.
Se han producido 10 cambios de contexto.
************************************************************
Simulación FIFO con 80 ciclos de control.
Todos los procesos han finalizado en 10 ciclos de control.
Se han simulado 3 procesos concurrentes.
Se han producido 7 cambios de contexto.
************************************************************
Simulación RR - Round Robin con 80 ciclos de control.
Todos los procesos han finalizado en 10 ciclos de control.
Se han simulado 3 procesos concurrentes.
Se han producido 9 cambios de contexto.
************************************************************
Simulación HRN con 80 ciclos de control.
Todos los procesos han finalizado en 22 ciclos de control.
Se han simulado 3 procesos concurrentes.
Se han producido 13 cambios de contexto.
************************************************************

Simulación RNM con 80 ciclos de control.
Todos los procesos han finalizado en 14 ciclos de control.
Se han simulado 3 procesos concurrentes.
Se han producido 14 cambios de contexto.
************************************************************
Simulación FIFO con 5 ciclos de control.
Se han simulado 20 procesos concurrentes.
Se han producido 3 cambios de contexto.
************************************************************
Simulación RR - Round Robin con 5 ciclos de control.
Se han simulado 20 procesos concurrentes.
Se han producido 5 cambios de contexto.
************************************************************
Simulación HRN con 5 ciclos de control.
Se han simulado 20 procesos concurrentes.
Se han producido 3 cambios de contexto.
************************************************************
Simulación RNM con 5 ciclos de control.
Se han simulado 20 procesos concurrentes.
Se han producido 5 cambios de contexto.
************************************************************
Simulación FIFO con 3 ciclos de control.
Se han simulado 10 procesos concurrentes.
Se han producido 1 cambios de contexto.
************************************************************
Simulación RR - Round Robin con 3 ciclos de control.
Se han simulado 10 procesos concurrentes.
Se han producido 3 cambios de contexto.
************************************************************
Simulación HRN con 3 ciclos de control.
Se han simulado 10 procesos concurrentes.
Se han producido 2 cambios de contexto.
************************************************************
Simulación RNM con 3 ciclos de control.
Se han simulado 10 procesos concurrentes.
Se han producido 3 cambios de contexto.
************************************************************
Simulación FIFO con 6 ciclos de control.
Se han simulado 5 procesos concurrentes.
Se han producido 4 cambios de contexto.
************************************************************
Simulación RR - Round Robin con 6 ciclos de control.
Se han simulado 5 procesos concurrentes.
Se han producido 6 cambios de contexto.
************************************************************
Simulación HRN con 6 ciclos de control.
Se han simulado 5 procesos concurrentes.
Se han producido 5 cambios de contexto.
************************************************************
Simulación RNM con 6 ciclos de control.
Se han simulado 5 procesos concurrentes.
Se han producido 6 cambios de contexto.
************************************************************
Simulación FIFO con 10 ciclos de control.
Se han simulado 3 procesos concurrentes.
Se han producido 7 cambios de contexto.
************************************************************
Simulación RR - Round Robin con 10 ciclos de control.
Se han simulado 3 procesos concurrentes.
Se han producido 9 cambios de contexto.
************************************************************
Simulación HRN con 10 ciclos de control.
Se han simulado 3 procesos concurrentes.
Se han producido 6 cambios de contexto.
************************************************************
Simulación RNM con 10 ciclos de control.
Se han simulado 3 procesos concurrentes.
Se han producido 10 cambios de contexto.
************************************************************
Simulación FIFO con 30 ciclos de control.
Todos los procesos han finalizado en 15 ciclos de control.
Se han simulado 6 procesos concurrentes.
Se han producido 11 cambios de contexto.
************************************************************
Simulación RR - Round Robin con 30 ciclos de control.
Se han simulado 6 procesos concurrentes.
Se han producido 30 cambios de contexto.
************************************************************
Simulación HRN con 30 ciclos de control.
Todos los procesos han finalizado en 15 ciclos de control.
Se han simulado 6 procesos concurrentes.
Se han producido 13 cambios de contexto.
************************************************************
Simulación RNM con 30 ciclos de control.
Todos los procesos han finalizado en 16 ciclos de control.
Se han simulado 6 procesos concurrentes.
Se han producido 16 cambios de contexto.
************************************************************
Simulación FIFO con 200 ciclos de control.
Todos los procesos han finalizado en 167 ciclos de control.
Se han simulado 50 procesos concurrentes.
Se han producido 113 cambios de contexto.
************************************************************
Simulación RR - Round Robin con 200 ciclos de control.
Todos los procesos han finalizado en 174 ciclos de control.
Se han simulado 50 procesos concurrentes.
Se han producido 174 cambios de contexto.
************************************************************
Simulación HRN con 200 ciclos de control.
Todos los procesos han finalizado en 161 ciclos de control.
Se han simulado 50 procesos concurrentes.
Se han producido 98 cambios de contexto.
************************************************************
Simulación RNM con 200 ciclos de control.
Todos los procesos han finalizado en 198 ciclos de control.
Se han simulado 50 procesos concurrentes.
Se han producido 198 cambios de contexto.
************************************************************
Simulación FIFO con 30 ciclos de control.
Todos los procesos han finalizado en 25 ciclos de control.
Se han simulado 10 procesos concurrentes.
Se han producido 19 cambios de contexto.
************************************************************
Simulación RR - Round Robin con 30 ciclos de control.
Se han simulado 10 procesos concurrentes.
Se han producido 30 cambios de contexto.
************************************************************
Simulación HRN con 30 ciclos de control.
Se han simulado 10 procesos concurrentes.
Se han producido 20 cambios de contexto.
************************************************************
Simulación RNM con 30 ciclos de control.
Se han simulado 10 procesos concurrentes.
Se han producido 30 cambios de contexto.
************************************************************
Simulación FIFO con 50 ciclos de control.
Todos los procesos han finalizado en 47 ciclos de control.
Se han simulado 15 procesos concurrentes.
Se han producido 33 cambios de contexto.
************************************************************
Simulación RR - Round Robin con 50 ciclos de control.
Se han simulado 15 procesos concurrentes.
Se han producido 50 cambios de contexto.
************************************************************
Simulación HRN con 50 ciclos de control.
Se han simulado 15 procesos concurrentes.
Se han producido 31 cambios de contexto.
************************************************************
Simulación RNM con 50 ciclos de control.
Todos los procesos han finalizado en 46 ciclos de control.
Se han simulado 15 procesos concurrentes.
Se han producido 46 cambios de contexto.
************************************************************
Simulación FIFO con 60 ciclos de control.
Todos los procesos han finalizado en 17 ciclos de control.
Se han simulado 8 procesos concurrentes.
Se han producido 13 cambios de contexto.
************************************************************
Simulación RR - Round Robin con 60 ciclos de control.
Todos los procesos han finalizado en 32 ciclos de control.
Se han simulado 8 procesos concurrentes.
Se han producido 32 cambios de contexto.
************************************************************
Simulación HRN con 60 ciclos de control.
Todos los procesos han finalizado en 29 ciclos de control.
Se han simulado 8 procesos concurrentes.
Se han producido 19 cambios de contexto.
************************************************************
Simulación RNM con 60 ciclos de control.
Todos los procesos han finalizado en 28 ciclos de control.
Se han simulado 8 procesos concurrentes.
Se han producido 28 cambios de contexto.

Inicio:   Fin:

Resultados y Conclusiones

La utilización de P.O.O. para la resolución del problema planteado ha resultado muy satisfactoria, destacándose las facilidades de la misma y del compilador utilizado (Turbo C++).

Los resultados obtenidos ratifican, como era de esperarse, las previsiones teóricas en cuanto a las diferencias en atención a los procesos por parte de las distintas estrategias, ya sea en cuanto a la secuencia de asignación del procesador como en cuanto a la cantidad de tiempo (ciclos de control) asignados a los distintos procesos.

Las diferencias indicadas se hacen presentes independientemente de si se ha trabajado con un número pequeño o grande, tanto de ciclos de control como de procesos.

La modalidad implementada de mostrar los resultados paso a paso por pantalla permite observar el comportamiento de cada algoritmo y facilita la comprensión de su funcionamiento.

Como era de esperarse, se observa que los algoritmos que tienden a lograr una mayor equitatividad en el uso del procesador son los que generan una mayor cantidad de cambios de contexto (asignación del procesador a otro proceso distinto del que estaba siendo ejecutado y que se ha interrumpido).

Asimismo y a modo ilustrativo se han volcado en la Tabla 15.1 y en la Tabla 15.2 los datos del archivo resumen (Procesos.txt) como una planilla condensada de los mismos.

Inicio:   Fin:
 
 

Para mayor información, seleccione una opción:

• Página principal.
• Página anterior.
• Página siguiente.
• Indice general.
• Indice detallado.
• Contactos.

Número de visitantes actuales disponible desde el 14/07/2002:

 

Autor: lrmdavid@exa.unne.edu.ar

Ó FACENA - http://exa.unne.edu.ar

Servicios WEB: webmaster@exa.unne.edu.ar