Implementación de simulación en lenguaje C del algoritmo de rotación de intervalos de tiempo y algoritmo de programación de prioridades
La programación de procesos es el contenido central de la gestión del procesador. Este experimento requiere escribir un programa de simulación de programación de procesos en un lenguaje de alto nivel para profundizar la comprensión de conceptos como el control de procesos y las colas de procesos, y experimentar y comprender la implementación específica del algoritmo del número primero y el algoritmo de rotación de intervalos de tiempo.
2. Contenido experimental
1. El diseño de la estructura PCB del bloque de control de procesos generalmente debe incluir la siguiente información:
Nombre del proceso, prioridad del proceso (o número de intervalos de tiempo de rotación), tiempo de CPU ocupado por el proceso, tiempo requerido para completar el proceso, Estado del proceso, puntero de la cola actual.
2. Escriba dos programas de algoritmo de programación:
Programa de algoritmo de programación de número de prioridad
Programa de algoritmo de programación de rotación de ciclo
3. Presione Preguntar para obtener resultados de salida.
3. Consejos y precauciones
Utilice dos algoritmos de programación para programar el proceso de la madera. Cada proceso puede tener tres estados: estado de ejecución (EJECUTAR), estado listo (LISTO, incluido el estado de espera) y estado de finalización (FINALIZAR). Se supone que el estado inicial es el estado listo.
(a) La estructura del bloque de control de proceso es la siguiente:
NOMBRE--identificador del proceso
PRIO/ROUND--prioridad del proceso/cada proceso rotación El número de intervalos de tiempo (establecido en una constante 2)
CPUTIME--El número acumulado de intervalos de CPU ocupados por el proceso
NEEDTIME--El número de intervalos de tiempo que el proceso aún debe completarse
ESTADO--Estado del proceso
SIGUIENTE--Puntero de cadena
Nota:
1. Para facilitar procesamiento, el tiempo de ejecución del proceso en el programa se expresa en intervalos de tiempo Calculado en unidades
2. La prioridad o intervalo de tiempo de rotación de cada proceso y el. El valor inicial del intervalo de tiempo de ejecución del proceso lo proporciona el usuario cuando el programa se está ejecutando.
(2) El estado listo y en espera del proceso es una estructura de lista vinculada, con los siguientes cuatro punteros:
EJECUTAR: el puntero del proceso actualmente en ejecución
LISTO - puntero de cabecera de cola bajo demanda
COLA - puntero de cola de cola bajo demanda
FINALIZAR - puntero de cabecera de cola de finalización
(3) Programa notas
1. En el algoritmo del número de prioridad, el valor inicial de la prioridad del proceso se establece en:
50-NEEDTIME
Cada vez que se ejecuta, el número de prioridad disminuye en 1, el número de intervalos de tiempo de la CPU aumenta en 1 y el número de intervalos de tiempo que aún requiere el proceso disminuye en 1.
En el método de rotación, se utiliza una unidad de intervalo de tiempo fija (dos intervalos de tiempo son una unidad. Cada vez que el proceso gira, el número de intervalos de tiempo de la CPU aumenta en 2 y el número de tiempo). los sectores que aún requiere el proceso se reducen en 2. Y salga de la CPU, vaya al final de la cola lista y espere la siguiente programación.
2. La estructura del módulo del programa es la siguiente:
El programa completo puede estar compuesto por el programa principal y los siguientes siete procesos:
( 1) INSERT1: en prioridad En el algoritmo de número de nivel, los PCB sin terminar se insertan en la cola lista en el orden del número de prioridad;
(2) INSERT2: en el método de rotación, una unidad de intervalo de tiempo (que es 2) se ejecutará pero la PCB del proceso inacabado se inserta al final de la cola lista;
(3)FIRSTIN: programa la primera cola lista para ingresar al proceso en ejecución;
(4)PRINT-- Muestra el estado y la información relacionada de todos los procesos después de cada ejecución.
(5)CREAR--Crear un nuevo proceso e insertar su PCB en la cola lista;
(6)PRISCH--Programar el proceso de acuerdo con el algoritmo de numeración de prioridad;
(7)ROUNDSCH--Programación de procesos mediante rotación de intervalos de tiempo.
El programa principal define la estructura de la PCB y otras variables relacionadas.
(4) Ejecutar y mostrar
Después de que el programa comience a ejecutarse, primero le preguntará: se le pide al usuario que seleccione un algoritmo, ingrese el nombre del proceso y el valor NEEDTIME correspondiente.
Los resultados que se muestran cada vez son los siguientes cinco campos:
nombre cputime needtime prioridad estado
Nota:
1. En el estado En el campo, "R" representa el estado de ejecución, "W" representa el estado listo (en espera) y "F" representa el estado de finalización.
2. Primero se debe mostrar el estado "R", luego el estado "W" y finalmente el estado "F".
3. En el estado "W", haga cola en orden de prioridad o en orden de turno; en el estado "F", haga cola en orden de finalización.
¿ver copia simple en portapapeles?
/*
Experimentos del sistema operativo con algoritmo de rotación de intervalos de tiempo y algoritmo de programación de prioridades
Por Visual C 6.0
*/
#include lt;stdio.hgt
#include lt;stdlib.hgt
#include; lt; string.hgt;
typedef struct node
{
nombre de char[20] /*Nombre del proceso*/
int prio; /*Prioridad del proceso*/
int round; /*Asignar intervalo de tiempo de CPU*/
int cputime /*tiempo de ejecución de CPU*/
int needtime /* El tiempo requerido para la ejecución del proceso*/
char state /* El estado del proceso, W - listo, R - en ejecución, F - completado*/
int count; /* Registra el número de ejecuciones*/
int cputime; /* cputtime; /* Tiempo de ejecución de la CPU*/
int needtime /* Tiempo de ejecución del proceso requerido*/
estado del carácter
nodo de estructura *siguiente /* Puntero a la lista vinculada*/
}PCB
PCB; *ready=NULL, *run=NULL, *finish=NULL /* Se definen tres colas: cola lista, cola de ejecución y cola final*/
int
void; GetFirst() /* Obtener el primer nodo de la cola lista*/
void Output(); /* Información de la cola de salida*/
void InsertPrio( PCB *in); /* Crea una cola de prioridad, cuanto menor sea el número de prioridad especificado, mayor será la prioridad*/
void InsertTime(PCB *in /* Cola de segmento de tiempo*/
void); InsertFinish(PCB *in); /* Cola de intervalo de tiempo*/
void PrioCreate() /* Función de entrada prioritaria*/
void TimeCreate( ); function*/
void Priority();
void RoundRun() /* Programación de rotación de intervalos de tiempo*/
int main(void)
{
char chose;
printf("Ingrese el número de procesos a crear:\n"); ,amp; num);
getchar();
printf("Ingrese la programación cumplida
método para el proceso: (P/R)\n");
scanf("c", amp.chose);
switch(chose)
{
caso 'P':
caso 'p':
PrioCreate()
Prioridad(); p> p>
descanso
caso 'R':
caso 'r':
TimeCreate(); > RoundRun ();
romper
predeterminado:
}
Salida(); > return 0;
}
void GetFirst() /* Obtener el primer nodo de cola listo */
{
ejecutar = listo ;
if(ready!=NULL)
{
run -gt; estado = 'R'; -gt ;siguiente;
ejecutar -gt; siguiente = NULL
}
}
}
{
PCB *p
p = listo
printf; (" Nombre del proceso \t prioridad \t rondas \t tiempo de CPU \t tiempo necesario \t estado del proceso \t contador \n")
while(p. =NULL)
p! =NULL)
{
printf("s\td\td\td\td\td\tc\td\n") , p-gt; , p -gt; prio, p-gt; ronda, p-gt; cputime, p-gt; tiempo de necesidad, p-gt; ; siguiente ;
}
p = finalizar
mientras(p!=NULL)
{
printf ("s\td\td\td\tc\td\n",p-gt;nombre,p-gt;prio,p-gt;ronda,p-gt.cputime,p-gt;needtime,p -gt ; estado, p-gt; contar);
p = p-gt;
}
p = ejecutar;
mientras(p! =NULL)
{
printf("s\td\td\td\td\tc\td\n", p-gt; nombre, p-gt; prio, p-gt; ronda, p-gt; cputime, p-gt; needtime, p-gt; estado, p-gt;
p = p-gt;
}
<p>}
void InsertPrio(PCB *in) /* Crea una cola de prioridad, especificando que cuanto menor sea el recuento de prioridades, menor será la prioridad*/
{
PCB *fst, *nxt;
fst = nxt = listo;
if(ready == NULL) /* primer elemento si la cola está vacía*/
{
in-gt; siguiente = listo;
listo = en
}
más /* buscar A la posición de inserción correcta */
{
if(in -gt; prio gt; = fst -gt; prio) /* Mayor que el primero, insertar en la cabeza del Departamento de cola*/
{
in-gt; next = listo
listo = in
salir(1);
}
scanf("s", tmp-gt; nombre);
getchar(); /p>
scanf("d", amp; (tmp-gt; needtime));
tmp -gt.cputime = 0
tmp -gt; = 'W ';
tmp -gt; prio = 0;
tmp -gt; round = 2 /*Supongamos que el intervalo de tiempo asignado a cada proceso es 2*/
tmp -gt; recuento = 0
InsertTime(tmp
}
}
}
void Priority() /*Programación según prioridad, ejecutando un segmento de tiempo a la vez*/
{
int flag = 1
GetFirst();
while( run != NULL) /* Cuando la cola lista no está vacía, el proceso de programación se ejecutará de acuerdo con la cola de ejecución */
{
Salida();/* Muestra el estado de cada nodo en cada proceso de programación*/
while(flag)
{
run- gt; prio -= 3; /* Prioridad menos tres*/
run-gt; /*intervalo de tiempo de CPU más uno*/
run-gt; needtime- - /* El tiempo restante para que el proceso complete la ejecución se reduce en uno */
if(run-gt; needtime == 0)/* Si el proceso completa la ejecución , establezca el estado del proceso en F y configúrelo Insertar en la cola de finalización*/
{
run -gt state = 'F'; gt; count; /* El número de veces que se ejecuta el proceso se suma 1*/
InsertFinish(run);
flag = 0;
else /* Establece el estado del proceso en W e ingresa a la cola listo* /
{
run-gt = 'W'; > ejecutar-gt;
count;/* Aumentar el número de ejecuciones de procesos en uno*/
InsertTime(run);
flag =
flag = 0; p>
}
}
}
flag = 1;
GetFirst() /* Continuar buscando el proceso al principio de la cola listo en la cola de ejecución */
}
}
}
}
void RoundRun() /* Algoritmo de programación circular de intervalos de tiempo*/
{
int flag = 1
GetFirst(); >
while(ejecutar != NULL)
{
Salida()
while(bandera)
{
ejecutar-gt; contar
ejecutar-gt;
ejecutar-gt; -gt; needtime == 0) /* Ejecución del proceso completada**
{
ejecutar -gt; estado = 'F'; );
flag = 0;
}
else if(run-gt; count == run-gt; round)/* el intervalo de tiempo se agota. */
{
run-gt; state = 'W';
run-gt; count = 0 /* contador borrado para la próxima vez* /
InsertTime(ejecutar);
bandera = 0
}
}
}
bandera = 1;
GetFirst()
}