Red de conocimiento informático - Computadora portátil - La programación en lenguaje C implementa el algoritmo de rotación de intervalos de tiempo. Intente escribirlo lo más simple y fácil de entender posible. Gracias.

La programación en lenguaje C implementa el algoritmo de rotación de intervalos de tiempo. Intente escribirlo lo más simple y fácil de entender posible. Gracias.

#include

#define MAX 5 //Número de procesos

#define RR 2 //Tamaño del intervalo de tiempo

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

struct pro

{

int num;

int ArrivalTime;

int burst;

int rt; //Registra el número de veces que se ha ejecutado el proceso

struct pro *next;

} ;

int TOTALTIME; //Registra el tiempo total de todos los procesos

//Declaración de función

struct pro* creatList();

void insert(struct pro *head,struct pro *s);

struct pro* searchByAT(struct pro *head,int AT

void del(struct pro*); p);

int getCount(struct pro *head,int time);

struct pro* searchEnd(struct pro *head);

void move( struct pro *headF,struct pro *headT,int n);

struct pro* creatList() //Crea una lista vinculada, organízala según la hora de llegada del proceso y registra la información de todos los procesos

{

struct pro* head=(struct pro*)malloc(sizeof(struct pro));

head->next=NULL;

struct pro* s;

p>

int i;

TOTALTIME=0;

for(i=0;i< MAX;i++)

{

s=(struct pro*)malloc(sizeof(struct pro));

printf("Ingrese el nombre del proceso :\n");

scanf("% d",&(s->num));

printf("Por favor, introduzca la hora de llegada:\n");

scanf("%d",&(s- >arriveTime));

printf("Ingrese el tiempo de ejecución:\n");

scanf("%d",&(s->burst));

TOTALTIME+=s->burst //Tiempo total de cálculo

s->rt=1; //El valor inicial de rt es 1

s->next =NULL;

insert(head,s);

}

return head; //Los procesos que llegan a la cola se organizan en el orden de su hora de llegada

}

void insert(struct pro *head,struct pro *s) //Insertar nodo

{

struct pro * p=searchByAT(head,s->arriveTi

yo);

s->siguiente=p->siguiente;

p->siguiente=s;

regresar;

}

struct pro* searchByAT(struct pro *head,int AT) //Encuentra el primer nodo cuyo tiempo de llegada sea mayor o igual a AT y devuelve su puntero anterior

{

struct pro *p,*q;

p=cabeza;

q=cabeza->siguiente;

mientras(q != NULL&&q->hora de llegada<=AT)

{

p=q;

q=q->siguiente;

}

return p;

}

void del(struct pro* p) //Eliminar el siguiente nodo de p

{

struct pro *tmp;

tmp=p->siguiente;

p->siguiente=tmp->siguiente;

free( tmp);

return;

}

int getCount(struct pro *head,int time) //Comprueba si llega antes de tiempo pero es no movido para ejecutar Número de procesos en la cola

{

int count=0;

struct pro *s,*t;

s=cabeza;

t=s->siguiente;

mientras(t!=NULL&&t->hora de llegada<=hora)

{

s =t;

t=t->next;

count++; //count registra el número de procesos que llegan en el momento actual

}

return count;

}

struct pro* searchEnd(struct pro *head) //Busca y devuelve el nodo antes del nodo de cola de la cola circular

{

struct pro *p,*q;

p=head;

q=head->next ;

mientras (q->siguiente!=cabeza)

{

p=q;

q=q->siguiente ;

}

return p;

}

movimiento vacío(struct pro *headF,struct pro *headT,int n) //Mover n nodos después de headF Mover a la cola circular headT

{

struct pro *r,*s,*t;

s=headF;

t=s->next;

r=t; //r registra el primer nodo que se moverá

while(n>1)

{

t=t->siguiente;

n--;

}

s->siguiente =t->next; //Lo anterior completa la eliminación de los nodos relevantes de la cola original, r y t son el primer y último nodo respectivamente

s=searchEnd(headT);

t->siguiente

=s->siguiente;

s->siguiente=r;

}

ejecución vacía (struct pro *head)

{

int time=0; //Registra la hora actual

int newarrive;//Número de procesos recién llegados

struct pro *runhead=(struct pro* )malloc(sizeof(struct pro));

runhead->next=runhead; //Crea una nueva lista circular enlazada para almacenar los procesos en la cola lista actual

struct pro *p ,*q;

p=runhead;

q=p->next; //q registra el proceso actual que debería estar ejecutándose

mientras(tiempo<= TIEMPO TOTAL)

{

newarrive=getCount(cabeza,tiempo);

if(newarrive>0)

move(head, runhead, newarrive); //Mover los nodos recién llegados después del encabezado a la cola de ejecución

if(runhead->next==runhead) //No hay ningún proceso en la cola de listos

tiempo++;

else if(q==runhead)

{

p=q;

q =q->siguiente;

}

else

{

printf("Nombre del proceso: %d\n",q ->num);

printf("Hora de llegada:%d\n",q->hora de llegada);

if(q->rt==1)

printf( "Tiempo de respuesta: %d\n", time-q->arriveTime);

else

printf("Hora de inicio de %dth ejecución: % d\n", q->rt,time);

if(q->burst<=RR)

{

tiempo+=q-> burst;

printf("Hora de finalización de la ejecución %dth: %d\n",q->rt,time);

printf("Tiempo de respuesta:%d\n ",hora- q->hora de llegada);

printf("****************************** ****** **\n");

struct pro *tmp=q;

q=q->siguiente;

p- >siguiente=q;

free(tmp);

}

else //q->burst>RR

{

time+=RR;

printf("Hora de finalización de %dth ejecución: %d\n",q->rt,time);

printf( "**** **********

************************\n");

q->burst-=RR;

q->rt++;

p=q;

q=q->siguiente;

}

}

}

}

void main()

{

struct pro *head=creatList();

printf("El tamaño del intervalo de tiempo actual es: %d\n",RR);

run(head);

}