Programación clásica y comentarios en lenguaje C
# include & ltwindows.h & gt
# include & ltstdlib.h & gt
operación de estructura typedef p>
{
int hora; //Cuando se usa para almacenar la entrada.
int min//Se utiliza para almacenar puntos de entrada.
int ID//Registra el número del trabajo.
int requesttime//El tiempo de ejecución estimado del trabajo de almacenamiento.
int runtime; //Tiempo de respuesta de la operación
int cometime//Tiempo de entrada del trabajo
int finishtime//Tiempo de finalización del trabajo
int starttime//hora de inicio del trabajo
Tiempo de ejecución de punto flotante 2; //tiempo de respuesta ponderado
int anterior//relación de respuesta
} trabajo;
tiempo de recuento flotante 1 = 0; //Se utiliza para almacenar el tiempo total de respuesta.
tiempo de recuento flotante 2 = 0; //Se utiliza para almacenar el tiempo de respuesta total ponderado.
int ahora
int flat = 0;
int sign = 0
void insert(trabajo[], trabajo);
void FCFS();
void SJF();
void HRN();
void getprior(TRABAJO a, int b);
int getmin(int I);
int gethour(int I);
int trans(int i, int j);
int gethour(int I);
int trans(int i, int j);
p>
#Definición número 100
Trabajo JOB[N];
Trabajo en espera[N]; //El tiempo de espera para los trabajos en el almacenamiento SJF
JOB JOB 2[N]; Es difícil controlar la salida en SJF, se almacena en una matriz en el orden de los números de serie del trabajo.
int co = 0;
int jobnum
void main()
{
int I;
Printf("Número de trabajo ingresado: \ n ");
scanf("%d ", & ampI);
núm de trabajo = I; /p>
ARCHIVO * fp
fp = fopen("in.txt", "Rb");
if(fp == NULL)
{
printf("no se puede abrir en . txt ");
Salir (0); int j = 0;j<j++)
{
fscanf(fp, " %d: %d %d ", & trabajo[j] . Hora&Job[j]. Mínimo&Job [j].
Trabajo[j]. ID = j+1;
Trabajo[j]. hora de llegada=trabajo[j]. horas*60 + trabajo[j]. min
printf("%d\n ", trabajo[j].
tiempo de solicitud);
}
printf(" \ n = = = = = = = = = = = = = = = = = = = = = = = = = = " );
printf(" \ n | 1:FCFS 2:SJF | "
printf(" \ n | 3:HRN | ");
printf(" \ n = = = = = = = = = = = = = = = = = = = = = = = = ");
printf(" \ nPor favor seleccione un número de (1, 2, 3):").
scanf("%d ", & ampI);
Conmutador (1)
{
Caso 1: FCFS() ; romper;
Caso 2: SJF(); Romper;
Caso 3: HRN(); }
void FCFS()
{
printf(" \ n \ nBasado en el algoritmo por orden de llegada:\ n ");
int k;
for(int I = 0; i<jobnum-1; i++) // Ordena la matriz de trabajos según el tiempo de entrada.
{
k = I
for(int j = I+1; j & ltjobnumj++)
{
if(trabajo[j].cometime & ltJob[k].cometime)k = j;
}
if (k!=i)
{
Trabajo a;
a = trabajo[k];
trabajo[k]= trabajo[I];
trabajo[I]= a;
}
}
for(int I = 0; i<jobnumi++)
{
If(i==0)//Si es la primera tarea
{
Trabajo[i]. hora de inicio=trabajo[i]. hora de llegar
Trabajo [I]. hora de finalización = trabajo [i]. hora de inicio+trabajo[i]. Pedir tiempo;
Trabajo [yo]. tiempo de ejecución = trabajos[i]. Completar la asignación de tiempo [i]. hora de llegada
Trabajo[i].Tiempo de ejecución 2=(Float)Trabajo[i]. trabajo en tiempo de ejecución/(punto flotante)[i]. Solicitar tiempo;
counttime1+=job[i]. Tiempo de ejecución;
tiempo de cuenta 2+= trabajo[I]. tiempo de ejecución 2;
}
Otros
{
Trabajo [yo]. hora de inicio=(trabajo[i-1].finishtime & gtjob[i].cometime?job[i-1].finish time:job[i].cometime);
Trabajo[i] ]. hora de finalización = trabajo [i]. hora de inicio+trabajo[i]. Pedir tiempo;
Trabajo [yo]. tiempo de ejecución = trabajos[i]. Completar la asignación de tiempo [i]. hora de llegada
Trabajo[i].Tiempo de ejecución 2=(Float)Trabajo[i]. trabajo en tiempo de ejecución/(punto flotante)[i]. Solicitar tiempo;
counttime1+=job[i].
Tiempo de ejecución;
tiempo de recuento 2+= trabajo[I].tiempo de ejecución 2;
}
}
Printf("Trabajo estimado tiempo de entrada, tiempo de ejecución, hora de inicio, hora de finalización, tiempo de respuesta y tiempo de respuesta ponderado\n ");
FILE * fp
fp = fopen("FCFS.txt ", "w");
if(fp==NULL)
{
printf("No se puede crear el archivo: sjf . txt \ n ");
Exit(0);
}
Fprintf(fp, "Tiempo estimado del trabajo, hora de inicio, hora de finalización, tiempo de respuesta ponderado\n");
for (int I = 0; I & ltjobnum-1; I++) // Ordena la matriz de trabajos por ID de trabajo.
{
k = I
for(int j = I+1; j & ltjobnumj++)
if(trabajo[ j].ID & ltJob[k].ID)
k = j;
if (k!=i)
{
Trabajo a;
a = trabajo[k];
trabajo[k]= trabajo[I];
trabajo[I]= a;
}
}
for(int I = 0; i<jobnumi++)
{
int a, b, c, d;
a=gethour(trabajo[i]). hora de inicio);
b=getmin(trabajo[i]). hora de inicio);
c=gethour(trabajo[i]). hora de finalización);
d=getmin(trabajo[i]). hora de finalización);
printf("Trabajo %d",Trabajo[i].ID);
fprintf(fp,"Trabajo %d",Trabajo[i].ID ); );
if(trabajo[i].valor mínimo==0)
{
printf("%d:%d0 ", trabajo [i ].horas,trabajo[i].min);
fprintf(fp," %d:%d0",trabajo[i].horas,trabajo[i].min);
}
Otro
{
printf("%d:%d ", trabajo[i]. horas, trabajo[i] .min );
fprintf(fp, " %d:%d ", trabajo [i]. horas, trabajo [i]. min
}
);printf("%11d ", trabajo[i].hora de solicitud);
fprintf(fp, "%11d", trabajo[i].
hora de solicitud);
If (b==0)
{
printf("%d:%d0 ",a,b);
p>
fprintf(fp, " %d:%d0 ", a, b
}
Otros
{
printf("%d:%d ", a, b);
fprintf(fp, " %d:%d ", a, b); >
}
if(d==0){
printf("%d:%d0 ", c, d); (fp, " % d:%d0 ", c, d
}
En caso contrario {
printf("%d:%d ", c, d);
fprintf(fp, " %d:%d ", c, d
}
printf(" % 11d %); 11f \ n ", trabajo[i].tiempo de ejecución, trabajo[I].tiempo de ejecución 2);
fprintf(fp, "%13d%13f\n", trabajo[i].tiempo de ejecución, trabajo[ I].runtime 2 );
}
Printf("Tiempo de respuesta promedio: % f \nTiempo de respuesta promedio ponderado: % f ", (flotante) counttime1/jobnum, count time 2/jobnum) ;
Fprintf(fp, "Tiempo de respuesta promedio: % f\nTiempo de respuesta promedio ponderado: % f ", (flotante) counttime1/jobnum, count time 2/jobnum);
system("pausa");
}
int trans(int i, int j)
{
devolver I * 6j;
}
int gethour(int i)
{
Devolver I/60;
}
int getmin(int i)
{
Retorno i % 60
}
void SJF()
{
printf(" \n \nSegún el algoritmo de prioridad de trabajo corto:\n ");
int k ;
p>for(int I = 0; i & ltjobnum-1; i++) // Ordena la matriz de trabajos según el tiempo de entrada.
{
k = I
for(int j = I+1; j & ltjobnumj++)
{
if(trabajo[j].cometime & ltJob[k].cometime)k = j;
}
if (k!=i)
{
Trabajo a;
a = trabajo[k];
trabajo[k]= trabajo[I];
trabajo[I]= a;
}
}
int números = jobnum
int realnum = jobnum
for(int I = 0; i<number; i++)
{
If(i==0)// Si es el primer tipo, ingrese directamente a la CPU para el cálculo.
{
Trabajo [yo]. hora de inicio=trabajo[i]. hora de llegar
Trabajo [I]. hora de finalización = trabajo [i]. hora de inicio+trabajo[i]. Pedir tiempo;
Trabajo [yo].
tiempo de ejecución = trabajos[i]. Completar la asignación de tiempo [i]. hora de llegada
Trabajo[i].Tiempo de ejecución 2=(Float)Trabajo[i]. trabajo en tiempo de ejecución/(punto flotante)[i]. Solicitar tiempo;
nowtime=job[i]. hora de finalización
cuentahora1+=trabajo[i]. tiempo de ejecución;
tiempo de cuenta 2+= trabajo[I]. tiempo de ejecución 2;
trabajo 2[co++]= trabajo[I];
for( int u = 0; u & ltjobnum-1; U++) // Elimina el primero de la secuencia de trabajos.
Trabajo[u]=Trabajo[u+1];
jobnum-;
int j = 0;
mientras( job[j].cometime & lt= nowtime & amp& ampj & ltJobnum)// Obtenga el trabajo en espera de la secuencia de trabajos restante y colóquelo en la secuencia de espera.
{
espera[plano++]= trabajo[j++];
}
int I = 0;
Si (j!=0)//j! =0 indica que el trabajo se ha transferido de la secuencia de trabajo a la secuencia en espera.
{
while(j & lt; Jobnum) // Elimina el trabajo transferido de la secuencia de trabajos.
{
Trabajo[I]=Trabajo[j];
i++; }
job num = I;
}
if(flat & gt; 1)//Si hay varios trabajos esperando en la secuencia de espera,
{
int r;
for(int x = 0; x & ltping-1; para ordenar.
{
r = x;
for(int y = x+1; y & ltping; y++)
{
if (espera[y].tiempo de solicitud & ltespera.tiempo de solicitud)
r = y;
}
if(r !=x)
{
Trabajar a;
a = esperar[r];
esperar[r] = esperar[ x];
espera[x]= a;
}
}
}
}
Otros
{
If(flat==0)//Si no hay secuencia de espera, es decir, no hay secuencia de espera, entonces el trabajo La secuencia será: El primer trabajo se coloca en la CPU y se ejecuta.
{
Trabajo[0]. hora de inicio=trabajo[0]. hora de llegada
Trabajo[0]. hora de finalización = trabajo [0]. Hora de inicio + trabajo[0]. Solicitar tiempo;
Trabajo[0]. tiempo de ejecución = trabajos[0]. Hora de finalización: trabajo[0]. hora de llegada
Trabajo[0].Tiempo de ejecución 2=(Flotante)Trabajo[0]. Trabajos en tiempo de ejecución/(punto flotante)[0]. Solicitar tiempo;
nowtime=trabajo[0]. hora de finalización
cuentahora1+=trabajo[0]. tiempo de ejecución;
tiempo de cuenta 2+= trabajo[0]. tiempo de ejecución 2;
trabajo 2[co++]= trabajo[0];
for( int u = 0; u & ltjobnum-1; U++) // Elimina el trabajo en ejecución de la secuencia de trabajos.
Trabajo[u]=Trabajo[u+1];
jobnum-;
int j = 0;
mientras( job[j].cometime & lt= nowtime & amp& ampj & ltJobnum)// Obtenga el trabajo en espera de la secuencia de trabajos restante y colóquelo en la secuencia de espera.
{
espera[plano++]= trabajo[j++];
}
int I = 0;
Si (j!=0)//j! =0 indica que el trabajo se ha transferido de la secuencia de trabajo a la secuencia en espera.
{
mientras(j & lt; númerotrabajo)
{
Trabajo[I]=Trabajo[j];
{ p>
i++;
j++;
}
núm de trabajo = j;
}
int r;
if(flat & gt; 1)//Si hay varios trabajos esperando en la secuencia de espera,
{
para(int x = 0;
{
r = x;
for(int y = x+1; y & ltping; y++)
{
if (espera[y].tiempo de solicitud & ltespera.tiempo de solicitud)r = y;
}
if(r!=x)
{
Trabajar a;
a = esperar[r];
espera[r]= esperar[x];
espera[x]= a;
}
}
}
}
Si no // De lo contrario, si hay un trabajo en espera en la secuencia de espera, llame al primer trabajo en la secuencia de espera.
{
Espera[0]. hora de inicio = horaahora
Espera[0]. tiempo de finalización = tiempo ahora + esperar [0]. Solicitar tiempo;
Esperar[0]. tiempo de ejecución = esperar[0]. Hora de finalización: espere [0]. hora de llegada
esperar[0]. tiempo de ejecución 2 =(flotar)(esperar[0]). tiempo de ejecución)/(flotante)(esperar[0]). tiempo de solicitud);
nowtime=wait[0]. tiempo de finalización
tiempo de cuenta1+=espera[0]. tiempo de ejecución;
tiempo de cuenta 2+= espera[0]. tiempo de ejecución 2;
trabajo 2[co++]= espera[0];
for( int i = 0;i<i++) //Eliminar el primer trabajo de la secuencia de espera de la espera.
espera[I]= espera[I+1];
Ping-;
int j = 0
mientras( job[j].cometime & lt= nowtime & amp& ampj & ltJobnum)// Obtenga el trabajo en espera de la secuencia de trabajos restante y colóquelo en la secuencia de espera.
{
espera[plano++]= trabajo[j++];
}
int I = 0;
Si (j!=0)//j! =0 indica que el trabajo se ha transferido de la secuencia de trabajo a la secuencia en espera.
{
if(j == 1 & amp; & ampJobnum == 1)//Si el último trabajo de la secuencia de trabajos se ha transferido al estado de espera, entonces el trabajo num Disminuye de 1 a cero.
jobnum-;
Otro
{
while(j <Jobnum)//De lo contrario, eliminar del trabajo Trabajos transferidos .
{
Trabajo[I]=Trabajo[j];
i++; }
número de trabajo = j;
}
}
int r;
if(plano & gt; 1) // Si hay más de una secuencia en espera, reordene.
{
for(int x = 0; x & ltping-1; X++) // Ordena la matriz de espera según el tiempo de ejecución estimado.
{
r = x;
for(int y = x+1; y & ltping; y++)
{
if (espera[y].tiempo de solicitud & ltespera.tiempo de solicitud)
r = y;
}
if(r !=x)
{
Trabajar a;
a = esperar[r];
esperar[r] = esperar[ x];
espera[x]= a;
}
}
}
}
}
}
Printf("Tiempo estimado de entrada del trabajo, tiempo de ejecución, hora de inicio, hora de finalización, tiempo de respuesta y tiempo de respuesta ponderado\n ");
ARCHIVO * fp
fp = fopen("SJF.txt "," w ");
if(fp==NULL)
{
printf("No se puede crear el archivo: sjf . txt \ n ");
Salir (0); >
Fprintf(fp, "Tiempo estimado del trabajo, hora de inicio, hora de finalización, tiempo de respuesta ponderado\n");
for(int I = 0; I<realnum-1 ;I++)//Ordenar la matriz de trabajos por ID de trabajo.
{
k = I
for(int j = I+1; j & ltrealnumj++)
if(trabajo2[ j].ID & ltjob2[k].ID)
k = j;
if (k!=i)
{
Trabajo a;
a = trabajo 2[k];
trabajo 2[k]= trabajo 2[I];
trabajo 2[I] ]= a;
}
}
for(int I = 0; i & ltrealnumi++)
{
int a, b, c, d;
a=gethour(trabajo2[i]). hora de inicio);
b=getmin(trabajo2[i]). hora de inicio);
c=gethour(trabajo2[i]). hora de finalización);
d=getmin(job2[i]). hora de finalización);
printf("Trabajo %d",Trabajo 2[i].ID);
fprintf(fp,"Trabajo %d",Trabajo 2[i] .
ID);
if(trabajo2[i].valor mínimo==0)
{
printf("%d:%d0 ", trabajo2[ i]. horas, trabajo2[i].min);
fprintf(fp, " %d:%d0 ", trabajo2[i]. horas, trabajo2[i].min);
}
Otro
{
printf("%d:%d ", trabajo2[i]. hora, trabajo2[i]. min);
fprintf(fp, " %d:%d ", trabajo2[i]. hora, trabajo2[i]. min
}
<); p>printf("%11d", trabajo2[i].tiempo de solicitud);fprintf(fp, "%11d", trabajo2[i].tiempo de solicitud);
if (b==0)
{
printf("%d:%d0 ", a, b
fprintf(fp, " %); d:%d0 ", a, b);
}
Otros
{
printf("%d:%d ", a, b);
fprintf(fp, " %d:%d ", a, b);
}
if(d= =0){
printf("%d:%d0 ", c, d);
fprintf(fp, " %d:%d0 ", c, d);
}
En caso contrario {
printf("%d:%d ", c, d
fprintf(fp, " %d:%d ", c, d);
}
printf(" % 11d % 11f \ n ", trabajo2[i].tiempo de ejecución, trabajo 2[I] ]. tiempo de ejecución 2);
fprintf(fp, " %13d%13f\n ", trabajo2[i]. tiempo de ejecución, trabajo 2[I]. tiempo de ejecución 2); }
Printf("Tiempo de respuesta promedio: % f \nTiempo de respuesta promedio ponderado: % f ", (flotante) counttime1/realnum, count time 2/realnum
Fprintf ( fp, "Tiempo de respuesta promedio: % f\nTiempo de respuesta promedio ponderado: % f ", (flotante)tiempo de conteo 1/número real, tiempo de conteo 2/número real
System("pause")); ;
}
HRN no válido()
{
co = 0;
printf(" \ n\nBasado en el algoritmo de prioridad de índice de respuesta más alto:\n ");
int k;
for(int I = 0; i<jobnum-1; I++)// Ordenar el Matriz de trabajos basada en el tiempo de entrada.
{
k = I
for(int j = I+1; j & ltjobnumj++)
{
if(trabajo[j].cometime & ltJob[k].cometime)k = j;
}
if (k!=i)
{
Trabajo a;
a = trabajo[k];
trabajo[k]= trabajo[I];
trabajo[I]= a;
}
}
nowtime=trabajo[0].
hora de llegada
for(int I = 0; i<jobnumi++)
{
int j = I;
int xx = I ;
while(j++ & lt;Jobnum)//Encuentre la prioridad de los trabajos sin terminar en secuencia.
Trabajo[j]. anterior = 1+(flotante)(ahora tiempo-trabajo[j].cometime)/trabajo[j]. Tiempo de solicitud;
int k;
for(int I = xx; i & ltjobnum-1; i++) // Ordena la matriz de trabajos de mayor a menor según la tasa de respuesta .
{
k = I
for(int j = I+1; j & ltjobnumj++)
{
if(trabajo[j].prior & gtTrabajo[k].prior)k = j;
}
if (k!=i)
{
Trabajo a;
a = trabajo[k];
trabajo[k]= trabajo[I];
p>
trabajo[I]= a;
}
}
if(trabajo[i].prior & gt=1) // Si hay una espera, haga que la hora de inicio de la espera sea igual a la hora actual.
Trabajo [yo]. hora de inicio = horaahora
Otro
Trabajo[I]. hora de inicio=trabajo[i]. cometime//Si no hay ningún trabajo en espera, la hora del siguiente primer trabajo se utilizará como hora de inicio y se asignará a la hora actual.
Trabajo [yo]. hora de finalización = trabajo [i]. hora de inicio+trabajo[i]. Pedir tiempo;
Trabajo [yo]. tiempo de ejecución = trabajos[i]. Completar la asignación de tiempo [i]. hora de llegada
Trabajo[i].Tiempo de ejecución 2=(Float)Trabajo[i]. tiempo de ejecución/trabajo[i]. Solicitar tiempo;
nowtime=job[i]. hora de finalización
cuentahora1+=trabajo[i]. Tiempo de ejecución;
tiempo de cuenta 2+= trabajo[I]. tiempo de ejecución 2;
trabajo 2[co++]= trabajo[I];
}< / p>
Printf("Tiempo estimado de entrada del trabajo, tiempo de ejecución, hora de inicio, hora de finalización, tiempo de respuesta y tiempo de respuesta ponderado\ n "); fp = fopen("HRN.txt "," w ");
if(fp==NULL)
{
printf("No se puede crear el archivo : sjf . txt \ n ");
Salir (0);
}
Fprintf(fp, "Tiempo estimado del trabajo, hora de inicio, hora de finalización , tiempo de respuesta ponderado\n");
for(int I = 0; i<jobnum-1; i++) // Ordena la matriz de trabajos por ID de trabajo.
{
k = I
for(int j = I+1; j & ltjobnumj++)
if(trabajo2[ j].ID<job2[k].
ID)
k = j;
si (k!=i)
{
Trabajar a;
a = trabajo 2[k];
trabajo 2[k]= trabajo 2[I];
trabajo 2[I]= a;
}
}
for(int I = 0;i<jobnumi++)
{
int a, b, c, d;
a=gethour(trabajo2[i]). hora de inicio);
b=getmin(trabajo2[i]). hora de inicio);
c=gethour(trabajo2[i]). hora de finalización);
d=getmin(job2[i]). hora de finalización);
printf("Trabajo %d",Trabajo 2[i].ID);
fprintf(fp,"Trabajo %d",Trabajo 2[i] .ID);
if(trabajo2[i].minimum==0)
{
printf("%d:%d0 ", trabajo2 [ i].hora,trabajo2[i].min);
fprintf(fp," %d:%d0",trabajo2[i].hora,trabajo2[i].min);
p>}
Otro
{
printf("%d:%d ", trabajo2[i]. hora, trabajo2[i] ] .min);
fprintf(fp, " %d:%d ", trabajo2[i].hora, trabajo2[i].min);
}
printf("%11d ", trabajo2[i].tiempo de solicitud);
fprintf(fp, " %11d ", trabajo2[i].tiempo de solicitud
<); p >If (b==0){
printf("%d:%d0 ", a, b
fprintf(fp, " %d:%d0 ", a, b);
}
Otros
{
printf("%d: % d ", a, b);
fprintf(fp, " %d:%d ", a, b);
}
if( d ==0){
printf("%d:%d0 ", c, d
fprintf(fp, " %d:%d0 ", c, d); ) ;
}
En caso contrario{
printf("%d:%d ",c,d);
fprintf( fp , " %d:%d ", c, d);
}
printf(" % 11d % 11f \ n ", trabajo2[i].tiempo de ejecución, trabajo 2 [ I]. tiempo de ejecución 2);
fprintf(fp, " %13d%13f\n ", trabajo2[i]. tiempo de ejecución, trabajo 2[I]. tiempo de ejecución 2);
}
Printf("Tiempo de respuesta promedio: % f \nTiempo de respuesta promedio ponderado: % f ", (flotante) counttime1/jobnum, count time 2/jobnum
Fprintf(fp, "Tiempo de respuesta promedio ponderado: % f\nTiempo de respuesta promedio ponderado: % f ", (flotante) counttime1/jobnum, count time 2/jobnum);
System("pause");
}
Programación de trabajos