Encuentre el código completo en lenguaje C del algoritmo de programación de procesos por orden de llegada y el algoritmo de prioridad de proceso corto

/* (1) Programación de procesos

Los algoritmos de programación de procesos incluyen FIFO, algoritmo de programación de prioridades, algoritmo de programación de rotación de intervalos de tiempo, algoritmo de programación jerárquica,

Entrada: Archivo de flujo de proceso, que almacena una serie de procesos a ejecutar.

Cada trabajo incluye tres elementos de datos:

El número de prioridad de tiempo requerido para el nombre del proceso (el nivel 0 es el más alto). )

Salida:

Tiempo de espera del flujo de ejecución del proceso y tiempo de espera promedio

Este programa incluye: FIFO, algoritmo de programación de prioridades, algoritmo de programación de rotación de intervalos de tiempo p>

Archivo de flujo de proceso process_stream.txt

Datos de prueba:

p0 16 2

p1 5 1

p2 4 3

p3 8 0

p4 9 4

p5 7 6

La depuración de VC pasó

*/

#include lt;stdio.hgt;

#include lt;string.hgt;

#include lt;iostream.hgt;

#include lt;stdlib.hgt;

const int Quatum=2; //Defina la duración del intervalo de tiempo en 2 segundos

const int MAXPCB=100; //Definir el número máximo de procesos

//Definir la estructura del proceso

typedef struct node

{

char name[20] ; //Nombre del proceso

int time; //Tiempo de ejecución del proceso

int privilegio; //Prioridad del proceso (estático)

int //Proceso finalizado; indicador de finalización, 0 -No completado, 1-Completado

int wait_time; //Tiempo de espera del proceso

}pcb;

pcb pcbs[MAXPCB];

int quantiry; //El número total de procesos en el archivo de flujo de proceso

void inicial()

{

int i;

for (i=0;ilt;MAXPCB;i)

{

strcpy(pcbs[i].name, "");

pcbs[ i].time=0;

pcbs[i].privilege=0

pcbs[i].finished=0; p> PCB[i] .wait_time=0;

}

cantidad=0

}

int readData()<; /p>

{

ARCHIVO *fp;

char fname[20];

int i

coutlt; lt; "Ingrese el nombre del archivo de flujo del proceso: "lt;lt;endl;

cingt;gt;fname;

if ((fp=fopen(fname, "r" ))==NULL)

{

coutlt;lt;"Error, el archivo no se puede abrir, verifique el nombre del archivo"lt;lt;endl;

p>

}

else

{

mientras (!feof(fp))

{

fscanf(fp, "s d d d", pcbs[cantidad].nombre,

amp; pcbs[cantidad].tiempo, amp; pcbs[cantidad].privilegio

); quantiry;

}

//Salir los datos leídos

coutlt;lt;"Salir los datos leídos"lt;lt;endl;

coutlt;lt;"El número total de procesos en el archivo de flujo de proceso="lt;lt;quantirylt;lt;endl;

coutlt;lt;"El número de prioridad de tiempo requerido del proceso nombre "lt;lt;endl;

for (i=0;ilt;quantiry;i)

{

coutlt;lt;" "lt; lt ;pcbs[i].namelt;lt;" "lt;lt;pcbs[i].timelt;lt;" "lt;lt;pcbs[i].privilegelt;lt;endl; }

devuelve 1;

}

devuelve 0;

}

//Restablecer datos a Para uso por otro algoritmo

void init()

{

int i;

for (i=0; ilt; MAXPCB ; i )

{

pcbs[i].finished=0

pcbs[i].wait_time=0

}

}

void FIFO()

{

int i, j

int total <; /p>

//Flujo de ejecución del algoritmo FIFO de salida

coutlt;lt;endllt;lt;"--------------------- ----- ------------------------------------------"lt; lt;endl;

coutlt;lt;"Flujo de ejecución del algoritmo FIFO:"lt;lt;endl

coutlt;lt;"Tiempo de espera del nombre del proceso"lt;lt;endl; ;

for (i=0;ilt;quantiry;i)

{

coutlt;lt;" "lt;lt;pcbs[i]. namelt;lt; " "lt;lt;pcbs[i].wait_timelt;lt;endl;

for (j=i 1;jlt;quantiry;j)

{

pcbs[j].wait_time =pcbs[i].time

}

}

total=0; >

for (i=0;ilt;quantiry;i)

{

total =pcbs[i].w

ait_time;

}

coutlt;lt;"Tiempo total de espera: "lt;lt;totallt;lt;" "lt;lt;"Tiempo promedio de espera: "lt;lt ;total/quantirylt;lt;endl;

}

//Algoritmo de programación de prioridades

void privilegio()

{< / p>

int i, j, p;

int pass_time=0;

int total

int cola[MAXPCB];

p>

int current_privielege=1000;

for (i=0; ilt; cantidad; i )

{

current_privielege= 1000;

for (j=0;jlt;quantiry;j)

{

if ((pcbs[j].finished==0 )amp;amp;( pcbs[j].privilegelt; current_privilege))

{

p=j;

current_privielege=pcbs[j].privilege ;

}

}

cola[i]=p

PCB[p].finalizado=1; >

pcbs[ p].wait_time =passed_time;

passed_time =pcbs[p].time;

}

//Programación de números de prioridad de salida flujo de ejecución

coutlt;lt;endllt;lt;"-------------------------------- -------- ---"lt;lt;endl;

coutlt;lt;"Flujo de ejecución de programación de número de prioridad: "lt;lt;endl;

coutlt;lt;"Tiempo de espera del nombre del proceso"lt;lt;endl;

for (i=0;ilt;quantiry;i)

{

coutlt;lt;" "lt; lt;pcbs[cola[i]].namelt;lt;" "lt;lt;pcbs[cola[i]].wait_timelt;lt;"--"lt;lt;cola[ i]lt;lt;endl;

}

total=0

para (i=0; ilt; cantidad; i )

{

total =pcbs[i].wait_time;

}

coutlt;lt;"Tiempo total de espera: "lt;lt;totallt ;lt;" Tiempo de espera promedio: "lt;lt;total/quantirylt;lt;endl;

}

//Algoritmo de programación de rotación de intervalos de tiempo

temporizador vacío()

{

int

i, j, suma, bandera=1;

int pass_time=0;

int max_time=0

int round=0;

int cola[1000];

int total=0

mientras(bandera==1)

{

bandera=0;

for (i=0; ilt; cantidad; i )

{

if (pcbs[i].finished==0)

{

bandera=1

cola[total]=i

total

si (pcbs[i].timelt;=Quatum*(ronda 1))

pcbs[i].finished=1;

}

} p>

ronda;

}

coutlt;lt;endllt;lt;"----------------- ------------------------------------------------- -"lt;lt;endl ;

coutlt;lt;"Flujo de ejecución de programación de rotación de intervalos de tiempo:";

for(i=0;ilt;total;i)

{

coutlt;lt;pcbs[queue[i]].namelt;lt;" ";

}

coutlt;lt ;endl;

coutlt;lt;"Nombre del proceso hora de finalización tiempo de ejecución tiempo de espera"lt;lt;endl;

sum=0;

for ( i=0;ilt;quantiry ;i )

{

for(j=total-1;jgt;=0;j--)//Compare la secuencia del flujo de ejecución de de atrás hacia adelante para encontrar Se puede calcular el tiempo de finalización de un proceso con el mismo nombre

{

if (strcmp(pcbs[queue[j]].name, pcbs[i ].name)==0)

{

coutlt;lt;" "lt;lt;pcbs[i].namelt;lt;" "lt;lt;(j 1)*Quatumlt;lt;" ";

coutlt;lt;pcbs[i].timelt;lt;" "lt;lt;(j 1)*Quatum-pcbs[i].timelt; lt;endl;

suma =(j 1)*Quatum-pcbs[i].time

descanso

}