En este artículo, discutimos sobre Clarividente SJF. Es un concepto teórico en el que el algoritmo mira hacia el futuro y espera a que llegue el proceso más corto, esto da como resultado el menor tiempo de espera promedio.
Diferencia entre Clairvoyant SJF y Shortest Job First :
ambos algoritmos funcionan con el mismo principio de asignar tiempo de CPU al proceso más corto. La diferencia radica en el hecho de que Clairvoyant puede mirar hacia el futuro y esperar el proceso más corto y asignar el recurso en consecuencia, mientras que SJF tiene que asignar los recursos al proceso que ya llegó (es decir, están esperando la cola lista).
Ejemplos:
Entrada: Los procesos son,
Process id Arrival time Burst time
p1 0 5
p2 1 2
p3 3 1
p4 4 3
Salida: La programación de procesos según Clairvoyant SJF es,
Process id Arrival time Burst time
p3 3 1
p2 1 2
p4 4 3
p1 0 5
El tiempo medio de espera es: 2,5
Salida: la programación del proceso según Shortest Job First es,
Process id Arrival time Burst time
p1 0 5
p3 3 1
p2 1 2
p4 4 3
El tiempo de espera promedio es: 2.75
Nota:
Clairvoyant SJF y SJF darán el mismo resultado si todos los procesos llegan al mismo tiempo.
Entrada: Los procesos son,
Process id Arrival time Burst time
p1 0 4
p2 0 9
p3 0 5
p4 0 3
Salida: La programación de procesos según Clairvoyant SJF es,
Process id Arrival time Burst time
p4 0 3
p1 0 4
p3 0 5
p2 0 9
El tiempo medio de espera es: 5,5
Salida: la programación del proceso según Shortest Job First es,
Process id Arrival time Burst time
p4 0 3
p1 0 4
p3 0 5
p2 0 9
El tiempo medio de espera es: 5,5
Código:
CPP
#include <bits/stdc++.h>
#define SIZE 4
using namespace std;
// Structure to store the information about the process
typedef struct proinfo {
string pname; // Process name
int atime; // Arrival time
int btime; // Burst time
} proinfo;
// This function schedules the process
// according to the Clairvoyant SJF scheduling algorithm.
void clairvoyantSjf(proinfo* arr)
{
// To sort the processes according to the burst time
int index = 0;
for (int i = 0; i < SIZE - 1; i++) {
index = i;
for (int j = i + 1; j < SIZE; j++) {
if (arr[j].btime < arr[index].btime) {
index = j;
}
}
swap(arr[i], arr[index]);
}
}
void display(proinfo* arr)
{
cout << endl;
cout << "Process id"
<< "\t";
cout << "Arrival time"
<< "\t";
cout << "Burst time"
<< "\t";
cout << endl;
for (int i = 0; i < SIZE; i++) {
cout << arr[i].pname << "\t\t";
cout << arr[i].atime << "\t\t";
cout << arr[i].btime << "\t\t";
cout << endl;
}
}
// To calculate the average waiting time
void avgWait(proinfo* arr)
{
int ctime = 0;
int twait = 0;
for (int i = 0; i < SIZE; i++) {
twait += abs(arr[i].atime - ctime);
ctime += arr[i].btime;
}
cout << "The average waiting time is: " << (float)twait / SIZE << endl;
}
int main()
{
// Array of process info structures.
proinfo arr[SIZE];
arr[0] = { "p1", 0, 5 };
arr[1] = { "p2", 1, 2 };
arr[2] = { "p3", 3, 1 };
arr[3] = { "p4", 4, 3 };
cout << "Process scheduling according to Clairvoyant SJF is: " << endl;
clairvoyantSjf(arr);
// To display the schedule
display(arr);
// to calculate the Average waiting time
avgWait(arr);
}
Java
// Java implementation of the approach
class GFG {
static int SIZE = 4;
// Class to store the information about the process
static class proinfo {
String pname; // Process name
int atime; // Arrival time
int btime; // Burst time
proinfo(String pname, int atime, int btime)
{
this.pname = pname;
this.atime = atime;
this.btime = btime;
}
}
// This function schedules the process
// according to the Clairvoyant SJF scheduling
// algorithm.
static void clairvoyantSjf(proinfo[] arr)
{
// To sort the processes according to the burst time
int index = 0;
for (int i = 0; i < SIZE - 1; i++) {
index = i;
for (int j = i + 1; j < SIZE; j++) {
if (arr[j].btime < arr[index].btime) {
index = j;
}
}
swap(arr, i, index);
}
}
static void swap(proinfo[] arr, int i, int index)
{
proinfo tmp = arr[i];
arr[i] = arr[index];
arr[index] = tmp;
}
static void display(proinfo[] arr)
{
System.out.println();
System.out.print("Process id\t");
System.out.print("Arrival time\t");
System.out.println("Burst time\t");
for (int i = 0; i < SIZE; i++) {
System.out.print(arr[i].pname + "\t\t");
System.out.print(arr[i].atime + "\t\t");
System.out.println(arr[i].btime + "\t\t");
}
}
// To calculate the average waiting time
static void avgWait(proinfo[] arr)
{
int ctime = 0;
int twait = 0;
for (int i = 0; i < SIZE; i++) {
twait += Math.abs(arr[i].atime - ctime);
ctime += arr[i].btime;
}
System.out.println("The average waiting time is: "
+ (float)twait / SIZE);
}
public static void main(String[] args)
{
proinfo[] arr = new proinfo[SIZE];
arr[0] = new proinfo("p1", 0, 5);
arr[1] = new proinfo("p2", 1, 2);
arr[2] = new proinfo("p3", 3, 1);
arr[3] = new proinfo("p4", 4, 3);
clairvoyantSjf(arr);
// To display the schedule
display(arr);
// to calculate the Average waiting time
avgWait(arr);
}
}
// This code is contributed by Karandeep Singh
Process scheduling according to Clairvoyant SJF is: Process id Arrival time Burst time p3 3 1 p2 1 2 p4 4 3 p1 0 5 The average waiting time is: 2.5
Publicación traducida automáticamente
Artículo escrito por DeveshRattan y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA