Cómo escribir un programa en C para implementar un algoritmo de programación SRTF (Tiempo más corto restante primero), junto con la visualización del diagrama de Gantt

Answer 1

Código

#include
int main ()
{
int en [10], bt [10], rt [10], endTime, i, el más pequeño;
int restantes = 0, n, tiempo, sum_wait = 0, sum_turnaround = 0;
printf (“Ingrese no de procesos:”);
scanf (“% d”, & n);
para (i = 0; i <n; i ++)
{
printf (“Ingrese la hora de llegada para el proceso P% d:”, i + 1);
scanf (“% d”, y en [i]);
printf (“Ingrese el tiempo de ráfaga para el proceso P% d:”, i + 1);
scanf (“% d”, & bt [i]);
rt [i] = bt [i];
}
printf (“\ n \ nProceso \ t | Tiempo de respuesta | Tiempo de espera \ n \ n”);
rt [9] = 9999;
for (tiempo = 0; permanecer! = n; tiempo ++)
{
más pequeño = 9;
para (i = 0; i <n; i ++)
{
if (en [i] <= tiempo && rt [i] 0)
{
más pequeño = i;
}
}
rt [el más pequeño] -;
if (rt [el más pequeño] == 0)
{
permanecer ++;
endTime = tiempo + 1;
printf (“\ nP [% d] \ t | \ t% d \ t | \ t% d”, más pequeño + 1, endTime-at [más pequeño], endTime-bt [más pequeño] -at [más pequeño]);
sum_wait + = endTime-bt [más pequeño] -at [más pequeño];
sum_turnaround + = endTime-at [más pequeño];
}
}
printf (“\ n \ nPromedio de tiempo de espera =% f \ n”, sum_wait * 1.0 / n);
printf (“Tiempo de respuesta promedio =% f”, sum_turnaround * 1.0 / 5);
devuelve 0;
}

Explicación del código

La línea no 8-15 se usa para tomar entradas. Las variables de matriz `at` y` bt` almacenan el tiempo de llegada y el tiempo de ráfaga de los procesos.
La matriz `rt` almacena el tiempo restante de los procesos que inicialmente son iguales al tiempo de ráfaga de los procesos. Este es el momento de completar la ejecución de todos los procesos.
La línea no 18 inicia un ciclo donde el tiempo comienza desde cero, la línea no 20 a la 27 se usa para encontrar un proceso que tenga el menor tiempo restante y su tiempo de llegada es menor o igual que el tiempo actual. Esta condición se verifica en cada unidad de tiempo, es por eso que el tiempo se incrementa en 1 (tiempo ++).
La línea no 26 se usa para imprimir el tiempo de llegada y el tiempo de ráfaga para los procesos terminados. En este momento, la variable `tiempo` da el tiempo de inicio del proceso.
Por lo tanto, Tiempo de respuesta = (tiempo + tiempo de ráfaga-hora de llegada),
Tiempo de espera = (hora – hora de llegada)
En la línea no 28, el tiempo restante para el proceso más corto se reduce en uno ya que el tiempo se incrementa en uno.
Si un proceso en particular acaba de terminar / completarse, entonces satisface la condición en la línea no 29 .
Dado que el tiempo variable almacena el tiempo actual, y el proceso se estaba ejecutando en este momento, por lo tanto, su tiempo de finalización = tiempo + 1 ( línea no 32 ).
Ya que
tiempo de ráfaga + tiempo de espera = hora de finalización – Hora de inicio
por lo tanto
tiempo de espera = tiempo final de tiempo de ráfaga-hora de llegada
El tiempo de espera y el tiempo de respuesta de todos los procesos se resumen y se dividen entre n para dar su promedio.

Answer 2

El algoritmo de programación de tiempo restante más corto (SRT) como el nombre sugiere, selecciona el proceso de ejecución que tiene la menor cantidad de tiempo restante hasta la finalización .

Se puede clasificar en dos partes:

• No preventivo : una vez seleccionado para su ejecución, un proceso continúa ejecutándose hasta el final de su ráfaga de CPU. También se conoce como Shortest Job First (SJF).
• Preemptive : el proceso que se está ejecutando actualmente, se ejecuta hasta que se completa o se agrega un nuevo proceso en el Programador de la CPU que requiere una menor cantidad de tiempo para la ejecución. También se conoce como el tiempo restante más corto primero (SRTF).

A diferencia del algoritmo de programación round robin, el algoritmo de programación de tiempo restante más corto puede conducir a la inanición . Si los procesos cortos se agregan continuamente al planificador de la CPU, entonces el proceso actualmente en ejecución nunca podrá ejecutarse, por lo tanto, SRT no está libre de inanición .

El tiempo restante más corto es óptimo y en su mayoría proporciona un tiempo de espera promedio mínimo para un conjunto dado de ráfagas de CPU de los procesos.

En SRT, nunca sabremos la próxima longitud de ráfaga . Solo podemos estimar la longitud de la próxima longitud de ráfaga.

CÓDIGO:

#include

principal()

{

int en [10], bt [10], rt [10], endTime, i, más pequeño, processGantt [100];

int restantes = 0, n, tiempo, sum_wait = 0, sum_turnaround = 0;

printf (“Ingrese no de procesos:”);

scanf (“% d”, & n);

para (i = 0; i

{

printf (“Ingrese la hora de llegada para el proceso P% d:”, i + 1);

scanf (“% d”, y en [i]);

printf (“Ingrese el tiempo de ráfaga para el proceso P% d:”, i + 1);

scanf (“% d”, & bt [i]);

rt [i] = bt [i];

}

printf (“\ n \ nProceso \ t | Tiempo de respuesta | Tiempo de espera \ n \ n”);

rt [9] = 9999;

for (tiempo = 0; permanecer! = n; tiempo ++)

{

más pequeño = 9;

para (i = 0; i

{

if (en [i] <= tiempo && rt [i] 0)

{

processGantt [tiempo] = i;

más pequeño = i;

}

}

rt [el más pequeño] -;

if (rt [el más pequeño] == 0)

{

permanecer ++;

endTime = tiempo + 1;

printf (“\ nP [% d] \ t | \ t% d \ t | \ t% d”, más pequeño + 1, endTime-at [más pequeño], endTime-bt [más pequeño] -at [más pequeño]);

sum_wait + = endTime-bt [más pequeño] -at [más pequeño];

sum_turnaround + = endTime-at [más pequeño];

}

}

printf (“\ n \ nPromedio de tiempo de espera =% f \ n”, sum_wait * 1.0 / n);

printf (“Tiempo de respuesta promedio =% f \ n \ n”, sum_turnaround * 1.0 / 5);

para (i = 0; i <= tiempo; i ++)

{

printf (“% d-> P% d”, i, processGantt [i] +1);

}

}

Answer 3

Existen principalmente dos tipos de algoritmos de programación en la CPU

1. Con derecho preferente
2. No preventivo

Si hablamos de implementar estos algoritmos de programación en C o en cualquier lenguaje, entonces los no preventivos son ciertamente más fáciles que implementar algoritmos preventivos.

El diagrama de Gantt suele ser el más importante de estos algoritmos.

Otros factores como tiempo de respuesta, tiempo de espera, rendimiento, tiempo de respuesta

son más fáciles de encontrar que imprimir el diagrama de Gantt (que básicamente muestra la ejecución del proceso en orden según el tiempo).

En el caso de la programación no preventiva, cada proceso se ejecutará solo una vez y deberá imprimir el tiempo de respuesta y el tiempo de finalización junto con la identificación del proceso.

Pero en caso de programación preventiva, tomemos SRTF (el tiempo restante más corto primero). La CPU comienza a ejecutar el proceso según el tiempo de llegada y, en ese momento, si un proceso que tiene un menor tiempo de ráfaga ingresa a la cola lista, el proceso actual pasará al estado de espera y la CPU ejecutará el proceso que tenga el menor tiempo de ráfaga.

Por lo tanto, en la programación preventiva no podemos predecir cuánto tiempo sufrirá nuestro diagrama de Gantt.

Esto imprimiría todos los parámetros junto con el diagrama de Gantt.

El siguiente algoritmo podría ayudarte ciertamente.

//Program for preemptive SJF or SRTF process scheduling

//Credits : 'Prateek Sahni'

#include
usando el espacio de nombres estándar;
#define MAX 15
int main ()
{
int número [MAX], ráfaga [MAX], llegada [MAX], respuesta [MAX], n, i, j, rem [MAX], ttime = 0, min, premin = n-1, respuesta [MAX];
cout << "Ingrese el número de procesos:";
cin >> n;
cout << "\ nIngrese el tiempo de llegada, el tiempo de ráfaga y la prioridad para cada proceso:";
para (i = 0; i {
número [i] = i + 1;
cout << "P" << i + 1 << ":";
cin >> llegada [i] >> explosión [i];
rem [i] = ráfaga [i];
ttime = ttime + burst [i];
}
cout << "Diagrama de Gantt:";
cout << "\ n";
para (i = 0; i <= ttime; i ++)
{
min = 0;
para (j = 0; j {
if (llegada [j] <= i && rem [j] <
rem [min] && rem [j]! = 0)
{
min = j;
}
}
if (rem [min] == ráfaga [min])
{
respuesta [min] = i;
}
if (premin! = min || i == 0)
{
cout << i << "" << "P" << número [min] << "";
}
rem [min] – = 1;
if (rem [min] == 0)
{
tiempo de respuesta [min] = llegada i [min]
+1;
}
premin = min;
}
cout << ttime << "\ n";
cout << "Tiempo de respuesta:";
para (i = 0; i {
cout << "P" << i + 1 << ":" << cambio [i] << "\ n";
}
cout << "Tiempo de espera:";
para (i = 0; i {
cout << "P" << i + 1 << ":" << cambio [i] -burst [i] << "\
norte”;
}
cout << "Tiempo de respuesta:";
para (i = 0; i {
cout << "P" << i + 1 << ":" << respuesta [i] << "\ n";
}
cout << "Rendimiento:" << n * 1000 / ttime << "procesos por segundo \ n";
devuelve 0;
}

La lógica principal implementada anteriormente es que necesita imprimir el diagrama de Gantt hasta el tiempo de ejecución total de todos los procesos (que se almacena en tiempo variable t).

Y en cada paso deberá elegir el tiempo más corto restante entre todo el proceso.

Espero que el programa anterior te pueda ayudar.

Answer 4

EXPLICACIÓN DEL CÓDIGO:

una CPU no ideal necesita al menos un proceso para llegar a tiempo 0. No puede seguir siendo ideal durante toda la ejecución.

línea 16–29: ordena la lista de procesos según su hora de llegada.

línea 30–54: recoge el trabajo más corto dentro del tiempo de CPU actual (puntero)

línea 58: selecciona el siguiente punto de interrupción de la CPU (el punto de interrupción no es más que el momento en que el planificador comprueba la cola lista para recoger el siguiente trabajo)

#include

int puntero, pre, a [15], b [15], r [15], cuenta = 0, n, pequeño, i, j, m, s = 0, k = 0, p [10], t [15 ] = {0}, w [15] = {0}, x, y, bs, temp, d = 0;

flotante att = 0, awt = 0;

int main ()

{

printf (“ingrese el número de proceso \ n”);

scanf (“% d”, & n);

para (i = 0; i

{

printf (“ingrese el proceso% d tiempo de llegada y tiempo de ráfaga \ n”, i + 1);

p [i] = i + 1;

scanf (“% d% d”, & a [i], & b [i]);

cuenta + = b [i];

r [i] = b [i];

}

para (x = 0; x

para (y = 0; y

if (a [y]> a [y + 1])

{

temp = a [y + 1];

a [y + 1] = a [y];

a [y] = temp;

temp = b [y + 1];

b [y + 1] = b [y];

b [y] = temp;

temp = p [y + 1];

p [y + 1] = p [y];

p [y] = temp;

}

while (puntero <= cuenta)

{

i = j = m = 0;

pre = puntero;

k = d + 1;

pequeño = 9999;

para (i = n-1; i> = 0; i–)

{

if (puntero

{

if (r [i] <= pequeño && r [i]> 0 && a [i] <= puntero)

{

pequeño = r [i];

j = i;

}

}

si no (puntero> = a [n-1])

{

if (r [i] <= pequeño && r [i]> 0)

{

pequeño = r [i];

j = i;

}

}

}

d = k;

while (a [s + d] == puntero)

d ++;

if (puntero == 0)

puntero = (a [d]> pequeño)? pequeño: a [d];

más

puntero = (s + d == n-1)? (pequeño <= a [n-2] -pointer)? puntero + pequeño: a [n-2] :( puntero> = a [n-1])? puntero + pequeño: (s + d

if (puntero-pre> 0)

r [j] = r [j] -pointer + pre;

if (puntero-pre> 0 && r [j]> = 0)

printf (“proceso% d: ejecutado% d /% d restante% d \ n”, p [j], puntero-pre, b [j], r [j]);

si (r [j] == 0)

t [j] = puntero-a [j];

}

printf (“\ n ****** REVISIÓN GENERAL DE LA PROGRAMACIÓN ***** \ n”);

para (i = 0; i

{

att + = t [i];

w [i] = t [i] -b [i];

awt + = w [i];

printf (“proceso% d: tiempo de espera:% d tiempo de respuesta:% d \ n”, p [i], w [i], t [i]);

}

printf (“\ n tiempo de espera promedio:% f \ n tiempo de respuesta promedio:% f \ n \ n”, awt / n, att / n);

devuelve 0;

}

Answer 5

#include
#include
int n, * a;
struct pro
{
int nombre, at, bt, tt, wt, izquierda, estado;
}*pags;
crear vacío (int num)
{
a = (int *) malloc (num * sizeof (int));
}
int smallers (int num)
{
int c = 0, i;
para (i = 0; i {
if ((p + i) -> bt status == 0)
{
* (a + c) = (p + i) -> bt;
c ++;
}
}
volver c;
}
int search (int num)
{
int i;
para (i = 0; i {
if ((p + i) -> bt == num && (p + i) -> status == 0)
volver i;
}
}
int main ()
{
int i, c_time = 0, b, s_nums, j, pro_num, p_time;
flotante att = 0, awt = 0;
printf (“Ingrese no. de procesos-“);
scanf (“% d”, & n);
crear (n);
p = (struct pro *) malloc (n * sizeof (struct pro));
para (i = 0; i (p + i) -> estado = 0;
printf (“- Ingrese el nombre del proceso, el tiempo de llegada y el tiempo de ráfaga de la CPU— \ n”);
para (i = 0; i scanf (“% d% d% d”, & (p + i) -> nombre, & (p + i) -> at, & (p + i) -> bt);
para (i = 0; i {
if ((p + i) -> status == 0)
{
b = (p + i) -> bt;
s_nums = smallers (b);
if (s_nums> 0)
{
(p + i) -> izquierda = (p + i) -> bt;
para (j = 0; j {
p_time = c_time;
pro_num = search (* (a + j));
if (c_time <(p + pro_num) -> at)
{
if ((p + i) -> left> (p + pro_num) -> at)
{
c_time = (p + pro_num) -> en;
(p + i) -> izquierda = (p + i) -> bt- (c_time-p_time);
c_time = c_time + (p + pro_num) -> bt;
(p + pro_num) -> estado = 1;
}
más
{
c_time = c_time + (p + i) -> bt;
(p + i) -> tt = c_time- (p + i) -> at;
(p + i) -> estado = 1;
if (c_time <(p + pro_num) -> at)
rotura;
}
}
más
{
c_time = c_time + (p + pro_num) -> bt;
}
(p + pro_num) -> tt = c_time- (p + pro_num) -> at;
(p + pro_num) -> estado = 1;
}
if ((p + i) -> status == 0)
{
c_time = c_time + (p + i) -> izquierda;
(p + i) -> tt = c_time- (p + i) -> at;
(p + i) -> estado = 1;
}
}
más
{
c_time = c_time + (p + i) -> bt;
(p + i) -> tt = c_time- (p + i) -> at;
(p + i) -> estado = 1;
}
}
}
printf (“\ nProcess \ t \ t Tiempo de llegada \ t \ tCPU Tiempo de ráfaga \ t \ tTurnAround Time \ t \ tWaiting Time \ n”);
para (i = 0; i {
(p + i) -> wt = (p + i) -> tt- (p + i) -> bt;
awt = awt + (p + i) -> wt;
att = att + (p + i) -> tt;
}
para (i = 0; i {
printf (“% d \ t \ t% d \ t \ t \ t% d \ t \ t \ t% d \ t \ t \ t% d \ n”, (p + i) -> nombre, (p + i) -> at, (p + i) -> bt, (p + i) -> tt, (p + i) -> wt);
}
printf (“\ n Tiempo de respuesta promedio:% f \ n”, att / n);
printf (“Tiempo de espera promedio:% f \ n \ n”, awt / n);
devuelve 0;
}

// SALIDA DE MUESTRA
/ * Ingrese no. de procesos- 4
—Introduzca el nombre del proceso, el tiempo de llegada y el tiempo de ráfaga de la CPU—
1 0 8
2 1 4
3 2 9
4 3 5

Tiempo de llegada del proceso Tiempo de ráfaga de CPU Tiempo de respuesta Tiempo de espera
1 0 8 17 9
2 1 4 4 0
3 2 9 24 15
4 3 5 7 2

Tiempo de respuesta promedio: 13.000000
Tiempo de espera promedio: 6.500000
* /

Answer 6

Aquí está el código que escribí que ilustra el algoritmo SRTF y también muestra el gráfico ghantt.

---

// *** CÓDIGO POR gOku ^ ***

#include

int main ()

{

int n, ari [10], bur [10], total = 0, i, j, pequeño, temp, procs [100], k, esperando [10], acabado [10];

flotante tavg = 0.0, wavg = 0.0;

printf (“INTRODUCIR EL NÚMERO DE PROCESOS:”);

scanf (“% d”, & n);

para (i = 0; i

{

printf (“INTRODUCIR EL TIEMPO DE PROCESO DE LLEGADA% d: \ t”, i);

scanf (“% d”, & ari [i]);

printf (“ENTRE EL TIEMPO DE EXPLOSIÓN DEL PROCESO% d: \ t”, i);

scanf (“% d”, & bur [i]);

esperando [i] = 0;

total + = fresa [i];

}

para (i = 0; i

{

para (j = i + 1; j

{

si (ari [i]> ari [j])

{

temp = ari [i];

ari [i] = ari [j];

ari [j] = temp;

temp = fresa [i];

bur [i] = bur [j];

bur [j] = temp;

}

}

}

para (i = 0; i

{

pequeño = 3200;

para (j = 0; j

{

if ((bur [j]! = 0) && (ari [j] <= i) && (bur [j]

{

pequeño = fresa [j]; k = j;

}

}

bur [k] -;

procs [i] = k;

}

k = 0;

para (i = 0; i

{

para (j = 0; j

{

if (procs [i] == j)

{

terminar [j] = i;

esperando [j] ++;

}

}

}

para (i = 0; i

{

printf (“\ nPROCESS% d: -FINISH TIME ==>% d TURNAROUND TIME ==>% d WAITING TIME ==>% d \ n”, i + 1, finish [i] +1, (finish [i] -ari [i]) + 1, (((terminar [i] +1) -esperando [i]) – ari [i]));

wavg = wavg + (((terminar [i] +1) -esperando [i]) – ari [i]);

tavg = tavg + ((terminar [i] -ari [i]) + 1);

}

printf (“\ n WAvG ==> \ t% f \ n TAVG ==> \ t% f \ n”, (wavg / n), (tavg / n));

devuelve 0;

}

/ * para mostrar el chat de ghantt, imprima el contenido de los procedimientos de la matriz [] * /

Avíseme si tiene algún problema para comprender el código.

Paz !

Answer 7

#include

int main ()

{

int en [10], bt [10], rt [10], endTime, i, el más pequeño;

int restantes = 0, n, tiempo, sum_wait = 0, sum_turnaround = 0;

printf (“Ingrese no de procesos:”);

scanf (“% d”, & n);

para (i = 0; i

{

printf (“Ingrese la hora de llegada para el proceso P% d:”, i + 1);

scanf (“% d”, y en [i]);

printf (“Ingrese el tiempo de ráfaga para el proceso P% d:”, i + 1);

scanf (“% d”, & bt [i]);

rt [i] = bt [i];

}

printf (“\ n \ nProceso \ t | Tiempo de respuesta | Tiempo de espera \ n \ n”);

rt [9] = 9999;

for (tiempo = 0; permanecer! = n; tiempo ++)

{

más pequeño = 9;

para (i = 0; i

{

if (en [i] <= tiempo && rt [i] 0)

{

más pequeño = i;

}

}

rt [el más pequeño] -;

if (rt [el más pequeño] == 0)

{

permanecer ++;

endTime = tiempo + 1;

printf (“\ nP [% d] \ t | \ t% d \ t | \ t% d”, más pequeño + 1, endTime-at [más pequeño], endTime-bt [más pequeño] -at [más pequeño]);

sum_wait + = endTime-bt [más pequeño] -at [más pequeño];

sum_turnaround + = endTime-at [más pequeño];

}

}

printf (“\ n \ nPromedio de tiempo de espera =% f \ n”, sum_wait * 1.0 / n);

printf (“Tiempo de respuesta promedio =% f”, sum_turnaround * 1.0 / 5);

devuelve 0;

}

Espero que este programa te ayude.

Answer 8

#include

int main()

{

int at[10],bt[10],rt[10],endTime,i,smallest;

int ,sum_wait=0,sum_turnaround=0; remain=0,n, time ,sum_wait=0,sum_turnaround=0;

printf ( "Enter no of Processes : " );

scanf ( "%d" ,&n);

for (i=0;i

{

printf ( "Enter arrival time for Process P%d : " ,i+1);

scanf ( "%d" ,&at[i]);

printf ( "Enter burst time for Process P%d : " ,i+1);

scanf ( "%d" ,&bt[i]);

rt[i]=bt[i];

}

printf ( "\n\nProcess\t|Turnaround Time| Waiting Time\n\n" );

rt[9]=9999;

for ( time =0;remain!=n; time ++)

{

smallest=9;

for (i=0;i

{

if (at[i]<= time && rt[i]0)

{

smallest=i;

}

}

rt[smallest]--;

if (rt[smallest]==0)

{

remain++;

endTime= time +1;

printf ( "\nP[%d]\t|\t%d\t|\t%d" ,smallest+1,endTime-at[smallest],endTime-bt[smallest]-at[smallest]);

sum_wait+=endTime-bt[smallest]-at[smallest];

sum_turnaround+=endTime-at[smallest];

}

}

printf ( "\n\nAverage waiting time = %f\n" ,sum_wait*1.0/n);

printf ( "Average Turnaround time = %f" ,sum_turnaround*1.0/5);

return 0;

}

Answer 9

Mira esto.