Experimento 1 Experimento de programación de procesos
【Propósito experimental】
(1) Profundizar en la comprensión del concepto de proceso y algoritmo de programación de procesos; realizar capacitación en programación.
(2) La programación del proceso es el contenido central de la gestión del procesador. Escriba y depure un programador de procesos simple usted mismo. A través de este experimento, puede profundizar su comprensión del concepto de bloques de control de procesos y colas de procesos, y comprender y comprender los métodos de implementación específicos de algoritmos tales como orden de llegada, prioridad de trabajo corto y programación de prioridad de alta prioridad.
【Experimente el contenido】
Diseñe un programa de simulación de programación de procesos con N procesos ejecutándose simultáneamente.
Algoritmo de programación del proceso: (1) Algoritmo de programación por orden de llegada: primero almacene todos los procesos en la cola al mismo tiempo de acuerdo con el momento de ingresar a la CPU (primero ingrese la presencia de la CPU cerca del jefe del equipo) y luego transfiera el proceso del jefe del equipo a Memoria, asigne recursos para él y póngalo en funcionamiento hasta que el proceso se complete por completo, y luego transfiéralo al primer proceso del equipo hasta que la cola esté vacía.
(2) Algoritmo de programación de prioridad de trabajo corto: primero organice todas las colas listas en el orden del tiempo restante de pequeño a grande, y almacénelas en la cola a su vez, y luego ejecútelas de acuerdo con el método de primer orden de llegada.
1. Cada proceso está representado por un bloque de control de proceso (PCB). El bloque de control de proceso contiene la siguiente información: nombre del proceso, prioridad, tiempo de llegada, tiempo de ejecución requerido, tiempo de CPU transcurrido, estado del proceso, etc.
2. La prioridad del proceso y el tiempo de ejecución requerido pueden especificarse manualmente de antemano, y el tiempo de ejecución del proceso se calcula en unidades de segmentos de tiempo.
3. El proceso listo solo puede ejecutarse una vez después de adquirir la CPU. Se expresa sumando 1 al tiempo de CPU ocupado.
4. Si el tiempo de CPU del proceso ha alcanzado el tiempo de ejecución requerido después de ejecutar un intervalo de tiempo, cancele el proceso. Si el tiempo de CPU del proceso no ha alcanzado el tiempo de ejecución requerido después de ejecutar un intervalo de tiempo, también Incluso si el proceso necesita continuar ejecutándose, la prioridad del proceso debe reducirse en 1 (es decir, reducirse en un nivel) y luego insertarse en la cola lista para la programación.
5. Imprima la PCB de cada proceso en el proceso en ejecución y la cola lista cada vez que se ejecuta el planificador para su inspección.
6. Repita el proceso anterior hasta completar todos los procesos requeridos.
【Ideas de diseño】
La esencia de la programación en el sistema operativo es un tipo de asignación de recursos, por lo que el algoritmo de programación se refiere a: el algoritmo de asignación de recursos especificado por la estrategia de asignación de recursos del sistema. Los algoritmos utilizados comúnmente para la programación de procesos son: programación por orden de llegada, programación de prioridad, programación de rotación de segmento de tiempo y programación de cola de retroalimentación multinivel. Este experimento consiste en diseñar los algoritmos de programación por orden de llegada, trabajo corto primero y dos, y comparar su rendimiento.El programa proporciona las funciones básicas de creación de procesos y selección de algoritmos de programación de procesos.
Primero, debe diseñar la estructura de datos, crear la estructura del proceso y luego diseñar cuidadosamente el algoritmo para cada programación del proceso, y usar el programa para implementarlo. Después de que el algoritmo esté diseñado, depure el programa general y pruébelo para comparar los pros y los contras de la programación de varios procesos en diferentes entornos.
Entre los algoritmos de programación existentes, algunos pelos cortos son adecuados para la programación de trabajos, y algunos algoritmos son adecuados para la programación de procesos; pero algunos algoritmos de programación se pueden usar tanto para la programación de trabajos como para la programación de procesos.
[Diagrama de flujo]
【Código del programa principal】
#include <stdio.h>
#define N 50
int main ()
{
void xfw (); // Primero en llegar, primer servicio
void dzy (); // Prioridad de trabajo corto
int a;
mientras (cierto)
{
printf ("\ n \ n");
printf ("Elija uno de los algoritmos de programación:");
printf ("\ n 1. Programación por orden de llegada");
printf ("\ n 2. Programación breve de prioridad de trabajo");
printf ("\ n 0, salir \ n");
printf ("\ n \ n Seleccione el elemento del menú:");
scanf ("% d", & a);
printf ("\ n");
interruptor (a) {
caso 1: xfw (); descanso;
caso 2: entre (); descanso;
predeterminado: descanso;
}
si (a <0 && a> 3) se rompe;
}
}
nulo xfw ()
{
int i, j, n, min, px; // n: número de procesos px: selección del modo de salida
flotante sum1, sum2;
printf ("Ingrese n procesos (0 <n <= 50):");
scanf ("% d", & n);
mientras que (n> 50 || n <= 0)
{
printf ("nIntroduzca de nuevo:");
scanf ("% d", & n);
}
printf ("\ n \ n");
estructura PCB {
int id; // Nombre del proceso
int dt; // hora de llegada
int st; // Tiempo de servicio
int wct; // Momento completo
float zt; // Tiempo de respuesta
float dczt; // Tiempo de respuesta ponderado
};
PCB a [N];
para (i = 0; i <n; i ++)
{
a [i] .id = i + 1;
printf ("Hora de llegada del proceso% d:", a [i] .id);
scanf ("% d", y a [i] .dt);
printf ("Proceso% d tiempo de servicio:", a [i] .id);
scanf ("% d", & a [i] .st);
printf ("\ n");
}
para (j = n-1; j> = 0; j--)
{
para (i = 0; i <j; i ++)
{
if (a [i] .dt> a [i + 1] .dt)
{
min = a [i] .id;
a [i] .id = a [i + 1] .id;
a [i + 1] .id = min;
min = a [i] .dt;
a [i] .dt = a [i + 1] .dt;
a [i + 1] .dt = min;
min = a [i] .st;
a [i] .st = a [i + 1] .st;
a [i + 1] .st = min;
}
}
}
a [0] .wct = a [0] .dt + a [0] .st; // Hora completa = hora de llegada + hora de servicio
a [0] .zt = (flotante) a [0] .st; // primer tiempo de respuesta = tiempo de servicio
a [0] .dczt = a [0] .zt / a [0] .st; // tiempo de respuesta ponderado = tiempo de rotación / tiempo de servicio
para (i = 1; i <n; i ++)
{
if (a [i] .dt> a [i-1] .wct) // Cuando llega un [i] hora> a [i-1] hora completa
{
a [i] .wct = a [i] .dt + a [i] .st; // a [i] hora de finalización = hora de llegada + hora de servicio
a [i] .zt = (float) a [i] .st; // En este momento, tiempo de respuesta = tiempo de servicio
a [i] .dczt = a [i] .zt / a [i] .st; // tiempo de respuesta ponderado = tiempo de rotación / tiempo de servicio
}
más
{
a [i] .wct = a [i-1] .wct + a [i] .st; // a [i] hora de finalización = a [i-1] hora de finalización + a [i] hora de servicio
a [i] .zt = (float) (a [i] .wct-a [i] .dt); // Tiempo de rotación = hora de finalización-hora de llegada
a [i] .dczt = a [i] .zt / a [i] .st; // tiempo de respuesta ponderado = tiempo de rotación / tiempo de servicio
}
}
printf ("1, salida \ n" en orden por número de identificación);
printf ("2. Salida \ n" en orden de finalización);
printf ("\ nSeleccione el orden de salida:");
scanf ("% d", & px);
printf ("\ nid: hora de llegada \ ttiempo de servicio \ ttiempo completo \ ttiempo de respuesta \ ttiempo de respuesta en potencia \ n");
sum1 = 0;
sum2 = 0;
cambiar (px)
{
caso 1: // 1. Salida en orden por número de identificación
{
para (j = 0; j <n; j ++)
{
para (i = 0; i <n; i ++)
if (a [i] .id == j + 1)
{
printf ("% d ：% d \ t \ t% d \ t \ t% d \ t \ t% .0f \ t \ t% .2f \ n", a [i] .id, a [i]. dt, a [i] .st, a [i] .wct, a [i] .zt, a [i] .dczt);
sum1 + = a [i] .zt;
sum2 + = a [i] .dczt;
}
}
printf ("\ n Tiempo de respuesta promedio:% .2f \ n", sum1 / n);
printf ("\ n Tiempo de respuesta ponderado promedio:% .2f \ n \ n", sum2 / n);
rotura;
}
caso 2: // 2. Salida en orden según el orden de finalización
{
para (i = 0; i <n; i ++)
{
printf ("% d ：% d \ t \ t% d \ t \ t% d \ t \ t% .0f \ t \ t% .2f \ n", a [i] .id, a [i]. dt, a [i] .st, a [i] .wct, a [i] .zt, a [i] .dczt);
sum1 + = a [i] .zt;
sum2 + = a [i] .dczt;
}
printf ("\ n Tiempo de respuesta promedio:% .2f \ n", sum1 / n);
printf ("\ n Tiempo de respuesta ponderado promedio:% .2f \ n \ n", sum2 / n);
rotura;
}
predeterminado: descanso;
}
}
nulo entre ()
{
int i, j, n, min, px; // n: número de procesos px: selección del modo de salida
int b = 0, z;
flotante sum1, sum2;
printf ("\ n Ingrese n procesos (0 <n <= 50):");
scanf ("% d / n", & n);
mientras que (n> 50 || n <= 0)
{
printf ("nIntroduzca de nuevo:");
scanf ("% d", & n);
}
printf ("\ n");
estructura PCB {
int id; // Nombre del proceso
int dt; // hora de llegada
int st; // Tiempo de servicio
int wct; // Momento completo
float zt; // Tiempo de respuesta
float dczt; // Tiempo de respuesta ponderado
};
PCB a [N];
para (i = 0; i <n; i ++)
{
a [i] .id = i + 1;
printf ("Hora de llegada del proceso% d:", a [i] .id);
scanf ("% d", y a [i] .dt);
printf ("Proceso% d tiempo de servicio:", a [i] .id);
scanf ("% d", & a [i] .st);
printf ("\ n");
}
min = a [0] .dt;
para (j = n-1; j> = 0; j--)
{
para (i = 0; i <j; i ++)
{
if (a [i] .dt> a [i + 1] .dt) // Si la hora de llegada de a [i]> la hora de llegada de a [i + 1]
{
min = a [i] .id;
a [i] .id = a [i + 1] .id;
a [i + 1] .id = min;
min = a [i] .dt;
a [i] .dt = a [i + 1] .dt;
a [i + 1] .dt = min;
min = a [i] .st;
a [i] .st = a [i + 1] .st;
a [i + 1] .st = min;
}
if (a [i] .dt == a [i + 1] .dt && a [i] .st> a [i + 1] .st) // llega al mismo tiempo y a [i] es más corto
{
min = a [i] .id;
a [i] .id = a [i + 1] .id;
a [i + 1] .id = min;
min = a [i] .dt;
a [i] .dt = a [i + 1] .dt;
a [i + 1] .dt = min;
min = a [i] .st;
a [i] .st = a [i + 1] .st;
a [i + 1] .st = min;
}
}
}
a [0] .wct = a [0] .st + a [0] .dt;
a [0] .zt = (flotante) a [0] .st;
a [0] .dczt = a [0] .zt / a [0] .st;
para (i = 1; i <n; i ++)
{
if (a [i] .dt> a [0] .wct);
de lo contrario b = b + 1;
}
para (j = b-1; j> = 1; j--)
{
para (i = 1; i <j; i ++)
{
if (a [i] .st> a [i + 1] .st)
{
min = a [i] .dt;
a [i] .dt = a [i + 1] .dt;
a [i + 1] .dt = min;
min = a [i] .st;
a [i] .st = a [i + 1] .st;
a [i + 1] .st = min;
min = a [i] .id;
a [i] .id = a [i + 1] .id;
a [i + 1] .id = min;
}
}
}
para (i = 1; i <n; i ++)
{
if (a [i] .dt> a [i-1] .wct)
{
a [i] .wct = a [i] .dt + a [i] .st;
a [i] .zt = (flotante) a [i] .st;
a [i] .dczt = a [i] .zt / a [i] .st;
}
más
{
a [i] .wct = a [i-1] .wct + a [i] .st;
a [i] .zt = (flotante) (a [i] .wct-a [i] .dt);
a [i] .dczt = a [i] .zt / a [i] .st;
}
para (j = i + 1, b = j; j <n; j ++)
{
if (a [j] .dt> a [i] .wct);
de lo contrario b = b + 1;
}
para (j = b-1; j> = i; j--)
{
para (z = i; z <j; z ++)
{
if (a [z] .st> a [z + 1] .st)
{
min = a [z] .dt;
a [z] .dt = a [z + 1] .dt;
a [z + 1] .dt = min;
min = a [z] .st;
a [z] .st = a [z + 1] .st;
a [z + 1] .st = min;
min = a [i] .id;
a [i] .id = a [i + 1] .id;
a [i + 1] .id = min;
}
}
}
}
printf ("\ nSeleccione el orden de salida \ n");
printf ("1, salida \ n" en orden por número de identificación);
printf ("2. Salida \ n" en orden de finalización);
scanf ("% d", & px);
printf ("\ nid: hora de llegada \ ttiempo de servicio \ ttiempo completo \ ttiempo de respuesta \ ttiempo de respuesta en potencia \ n");
sum1 = 0;
sum2 = 0;
cambiar (px)
{
caso 1: // 1, salida en orden según el número de identificación
{
para (j = 0; j <n; j ++)
{
para (i = 0; i <n; i ++)
if (a [i] .id == j + 1)
{
printf ("% d ：% d \ t \ t% d \ t \ t% d \ t \ t% .0f \ t \ t% .2f \ n", a [i] .id, a [i]. dt, a [i] .st, a [i] .wct, a [i] .zt, a [i] .dczt);
sum1 + = a [i] .zt;
sum2 + = a [i] .dczt;
}
}
printf ("\ n Tiempo de respuesta promedio:% .2f \ n", sum1 / n);
printf ("\ n Tiempo de respuesta ponderado promedio:% .2f \ n \ n", sum2 / n);
rotura;
}
caso 2: // 2, salida en orden según el orden de finalización
{
para (i = 0; i <n; i ++)
{
printf ("% d ：% d \ t \ t% d \ t \ t% d \ t \ t% .0f \ t \ t% .2f \ n", a [i] .id, a [i]. dt, a [i] .st, a [i] .wct, a [i] .zt, a [i] .dczt);
sum1 + = a [i] .zt;
sum2 + = a [i] .dczt;
}
printf ("\ n Tiempo de respuesta promedio:% .2f \ n", sum1 / n);
printf ("\ n Tiempo de respuesta ponderado promedio:% .2f \ n \ n", sum2 / n);
rotura;
}
predeterminado: descanso;
}
}
【Resultado de la prueba】
1. Programación por orden de llegada:
2. Programación breve de prioridad de trabajo:
【Resumen del experimento】
A través del diseño de este curso, tengo una sólida comprensión del conocimiento sobre el sistema operativo, especialmente el proceso y varios algoritmos de programación. Aunque la programación de procesos es una programación de bajo nivel dentro del sistema, la calidad de la programación de procesos afecta directamente el rendimiento de la programación de trabajos. El tiempo de respuesta y el tiempo de respuesta promedio que reflejan los méritos de la programación del trabajo solo reflejan el rendimiento de la programación del proceso hasta cierto punto. Por ejemplo, la parte del tiempo de ejecución en realidad incluye el tiempo de espera del proceso (incluido el tiempo de espera en el estado listo) y el proceso La cantidad de tiempo de espera depende de la estrategia de programación del proceso y de cuándo ocurre el evento de espera. Por lo tanto, la negociación del rendimiento de la programación del proceso es un indicador importante del diseño del sistema operativo. Por lo tanto, no se puede ignorar la importancia de la programación de procesos.