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);
}