Algoritmo de programación del proceso de rotación de intervalos de tiempo basado en prioridades

#includelt;iostreamgt;

usando el espacio de nombres std;

struct PCB_Type{

nombre de char;

int cpu_time

};

struct QueueNode{

struct PCB_Type PCB

struct QueueNode

};

int main(){

int m, n, t

int usecpu=0, unusecpu=0;

coutlt;lt;"Ingrese el número de procesos en la cola lista m:";

cingt;gt;m;

coutlt;lt;"Ingrese el número de procesos en la cola de bloqueo El número n: ";

cingt; gt; n;

coutlt; lt; "Ingrese el número de intervalos de tiempo t para activar los recursos del sistema: ";

cingt; gt; t;

struct QueueNode *readyhead=nuevo QueueNode, *readytail=nuevo QueueNode,

*blockedhead=nuevo QueueNode, * cola bloqueada=new QueueNode;

// readyhead=NULL; readytail=NULL; bloqueada=NULL;

readyhead=readytail; cabeza bloqueada=cola bloqueada

for(int i=1; ilt; = m; i){

struct QueueNode *t1=new QueueNode;

coutlt; lt;"Ingrese el valor del proceso en el nombre de la cola lista y cpu_time: ";

cingt;gt;t1-gt;PCB.namegt;gt;t1-gt;PCB.cpu_time;

readytail-gt; siguiente=t1;

readytail=t1;

}

for(int j=1; jlt; =n ; j ){

struct QueueNode *t2=new QueueNode;

coutlt;lt;"Ingrese el nombre y cpu_time del proceso en la cola de bloqueo:";

cingt;gt;t2-gt;PCB.namegt;gt ; t2-gt; PCB.cpu_time;

bloqueado-gt;siguiente=t2;

}

cout<

3-gt;siguiente){

coutlt;lt;t3-gt;PCB.namelt;lt;", "lt;lt;t3-gt;PCB.cpu_timelt;lt;"---gt ; ";

}

coutlt;lt;"Sin proceso";

coutlt;lt;endl;

coutlt;lt ;"Envíe la información del proceso de la cola bloqueada:";

struct QueueNode *t4;

t4=blockedhead-gt;next;

while(t4 != bloqueadotail-gt;siguiente){

coutlt;lt;t4-gt;PCB.namelt;lt;", "lt;lt;t4-gt;PCB.cpu_timelt;lt;"-- -gt ; ";

t4=t4-gt; siguiente;

}

coutlt; lt; "Sin proceso";

coutlt ;lt;endllt;lt;"La secuencia de ejecución del proceso:";

int x=0;

while(readyhead!=readytail||blockedhead!=blockedtail ){

int x=0;

p>

if(readyhead!=readytail){

struct QueueNode *p=readyhead-gt; siguiente;

coutlt;lt;p-gt;PCB.namelt;

p-gt; > usecpu;

if(readyhead-gt; next!=readytail) {

if(p-gt; PCB.cpu_timegt; 0){

readyhead -gt; siguiente=p-gt; // quitar de la cola

readytail-gt; siguiente=p; p>

else{

readyhead-gt;next= p-gt;

eliminar

}

}

else//Solo hay dos encabezados de nodo en la cola Punto y nodo de cola

{

if(p-gt;PCB.cpu_timelt; =0){readytail=readyhead; //Solo si el proceso ha finalizado la ejecución, la ejecución continuará. Una vez completada, borre la cola y suelte el puntero p; p; }

}

}

más

{

unusecpu; > coutlt;lt; "_,";

}

x

si(

x==t){

if(blockedhead!=blockedtail){

struct QueueNode *q=blockedhead-gt; next;

if(blockedhead- gt; siguiente!=cola bloqueada)

{

cabeza bloqueada-gt; siguiente=q-gt;

{

cabeza bloqueada=cola bloqueada

}

readytail-gt; =q;

x=0;

}

}

}

endl; ;

coutlt;lt;"cpu utilization="lt;lt;usecpult;lt;"/"lt;lt;usecpu unusecpult;lt;endl;

devuelve 0 ;

}

#include "stdio.h"

#include "stdlib.h"

#include "string.h "

#define ESPERA 1

#define EJECUTAR 2

#define FINALIZAR 3

typedef struct pcb

{

int num;

struct pcb *siguiente;

int prioridad;

int timeneed;

int state;

}pcb;/*Utilice esta estructura para simular un proceso*/

struct pcb *head;

struct pcb *run; >

pcb *jccret(int n)/*Esta función se utiliza para crear una cola de procesos*/

{

int i=1;

pcb *head, *p, *q;

randomize();/*Inicialización de función aleatoria*/

head=(pcb *)malloc(sizeof(pcb) ) ;/*Crear un encabezado vacío*/

p=head;

for(i=1;ilt;=n;i)/*Usar un bucle para crear el encabezado especificado Nodo*/

{

q=(pcb *)malloc(sizeof(pcb));

p-gt; next=q;

q-gt; num=i;

q-gt; siguiente=NULL

q-gt; Prioridad generada*/

q-gt; timeneed=random(10); /*Tiempo de ejecución generado aleatoriamente*/

q-gt; p>p=q;

}

cabezal de retorno;/*puntero de encabezado de tabla de retorno*/

}

pcb *getmaxpriority (estructura pcb *cabeza)/*

Esta función se utiliza para seleccionar un proceso con la mayor prioridad para ejecutar */

{

struct pcb *p, *q;

int max;

p>

p=head-gt;next;

max=p-gt;priority;/*El máximo inicial es la prioridad del nodo principal*/

q =p;

while(p) /*Cuando p no está vacío, comparar uno por uno*/

{

if (p-gt; prioridadgt ;max)/*Compare uno por uno y seleccione el nodo con mayor prioridad*/

{max=p-gt;priority;

q= p;}

p=p-gt;siguiente;

}

return q;

}

void delect(struct pcb * head, struct pcb *run)/*Esta función se utiliza para eliminar el proceso en ejecución de la cola de procesos*/

{

struct pcb *q =head;

while(q-gt;next)/*Escanea la cola de procesos y encuentra el proceso que ha completado su ejecución*/

{

if (q-gt;next-gt;num ==run-gt; num)/*Juzga si es un proceso completado*/

{

if(run-gt; siguiente!=NULL)

q-gt; siguiente=ejecutar-gt; siguiente

else q-gt; siguiente=NULL

libre(ejecutar; ); /*Liberar el espacio solicitado*/

return;

}

q=q-gt;next;

}

}

p>

void control()/*Esta función se utiliza para controlar la ejecución y programación de cada proceso*/

{

struct pcb *p;

run=head-gt; next; /*Inicialmente deja que se ejecute el primer proceso*/

run-gt; ;

while(run) /*when Ejecutar cuando el estado del proceso no está vacío*/

{

if(run-gt; timeneedgt; 0) /*Si el tiempo requerido para el proceso señalado por el puntero de ejecución actual no es cero, el estado es en ejecución, deje que este proceso se ejecute*/

if(run-gt; state==RUN)

{printf("pcbd se está ejecutando.\n", run-gt;num);

printf("Lista de espera:");/*Mostrar toda la cola de espera*/

p=head-gt;siguiente;

mientras(p)

{

si(p!=ejecutar)

printf("pcbd ",p-gt;num);

p=p-gt;siguiente;

}

printf( "\n");

delay(10000000);/ *Simular proceso en ejecución*/

run-gt; timeneed--;/*El proceso necesita tiempo menos uno*/

run-gt; prioridad=run-gt; prioridad-3 ;/*Reducir la prioridad del proceso en tres*/

}

if(run-gt) ; tiemponecesario!=0)