(****************************)

ESPECIFICACION

ENTRADA : SECUENCIA DE BCP, SECUENCIA DE INTERRUPCION

SALIDA : SECUENCIA DE ENTERO (*para denotar el orden de ejecuci
PRECONDICION :
FUNCION : ShorstestJobFirst(AP: SECUENCIA, I: SECUENCIA)
POSTCONDICION :
(**********Declaracion de tipos********)
PSEUDOCODIGO ALGORITMO_SJF
TIPO
REGISTRO BCP
idProceso: ENTERO
nombreProceso: CADENA
tiempoLlegada: ENTERO
tiempoDuracion: ENTERO
tiempoInicioEjecucion: ENTERO
memoriaBase : ENTERO
memoriaLimite: ENTERO
puntoParalizado: ENTERO
tiempoEsperaActual: ENTERO
tiempoEsperaTotal: ENTERO
FIN REGISTRO
REGISTRO TIPO_INTERRUPCION
idInterrupcion: ENTERO
nombreInterrupcion: CADENA
REGISTRO INTERRUPCION
idInterrupcion: ENTERO
tiempoLlegada: ENTERO
duracion: ENTERO
FIN REGISTRO
(*********Variables Globaless*********)
VAR
TablaProcesos: VECTOR DE PCB
N: ENTERO (*tamano de la tabla de procesos*)

FUNCION PRINCIPAL
VAR
RESP: BOOLEANO
Respuesta: CARACTER
(*Inicializa las tipos de interrupciones admitidos*)
llenarInterrupciones()
MIENTRAS (RESP)
LeerProcesos();
LeerInterrupciones();

ShortestJobFirst();
mostrarResultados();
(*podrhaber un men de opciones para agregar
mas procesos, e interrupciones, y la opcilankificar
de nuevo seria una mas de la lsita*)
ESCRIBIR ("Desea planificar de nuevo? S/N")
LEER (Respuesta)
SI (Respuesta = S )
RESP = VERDADERO
SINO
RESP = FALSO
FIN MIENTRAS
FIN PRINCIPAL

FUNCION ShorstestJobFirst (procesos: VECTOR DE PROCESO, interrupciones:

VECTOR DE INTERRUPCION)
(*MAX_TIME es la suma de todos los tiempos de ejecucide
interrupciones*)
VAR
MAX_TIME : ENTERO

procesos e

INICIO
MAX_TIME = CALCULAR_STE() (*Calcula la suma de tiempos de ejecucion*)
PARA I = 1 HASTA MAX_TIME HACER
INICIO
(*Verifica el estado de las estructuras*)
INDICE_PROCESONUEVO = LLEGOUNPROCESO(I) (*if el i es igual al proceso.
tiempo de llegada*)
INDICE_TERMINADO = TERMINO_UN_PROCESO(I) (*if el i es igual al proceso.
tiempo de salida*)
INDICE_INTERRUPCION = HAYINTERRUPCION(I) (*busca si coincide el punto de
llegada de la interrupcion con el i*)
SI (INDICE_PROCESONUEVO <> -1) ENTONCES
ENCOLAR_EN_LISTOS (INDICE_PROCESO)
(*La cola contendrun m do que reordena cuando alguien entra*)
FIN SI
(*Si el proceso ha finalizado (si no hay ninguno devuelve -1 tambien)*)
(*SI (INDICE_TERMINADO = -1 Y INDICE_INTERRUPCION <> -1) ENTONCES
PEJECUCION = PLANIFICAR();
FIN SI*)
(* si no hay interrupcion*)
SI (INDICE_INTERRUPCION <> -1)
PROCESOS[INDICE_PEJECUCION].TIEMPOESPERATOTAL +=
INTERRUPCIONES[I].DURACION
PROCESOS[INDICE_PEJECUCION].TIEMPOESPERAACTUAL =
INTERRUPCIONES[I].DURACION
PROCESOS[INDICE_PEJECUCION].FALTA EJECUTAR =
PROCESOS[INDICE_PEJECUCION].TInicioEjecucion +
PROCESOS[INDICE_PEJECUCION].duracispan> - I
ENCOLAR_EN_ESPERA(INDICE_PEJECUCION)
PEjecucion = PLANIFICAR(I)
(* El m do debe buscar en la cola de listos el mas corto

Y en la cola de espera debe verificar si alguno ya termino

(ptoParalizado + tiempoEsperaActual = I)
si ya termino entonces el partro de medicii es el mas corto
ser falta ejecutar) *)
FIN SI
FIN PARA
FIN ShorstestJobFirst

FUNCION PLANIFICAR(I: ENTERO ) DEV ENTERO

VAR
MENORL, MENORS: ENTERO
INICIO
MENORL = POSICION(COLA_LISTOS, 1) (*LA CIMA*)
MENORS = MENOR_FALTA_EJECUCION ()
SI (MENORL>MENORS) ENTONCES
INDICE_PEJECUTAR = MENORL
SINO
INDICE_PEJECUTAR = MENORS
FIN SI

RETORNAR
FIN PLANIFICAR

INDICE_PEJECUTAR

FUNCION MENOR_Falta_ejecucion (I: ENTERO ) DEV ENTERO

VAR
MENOR: ENTERO
P: BCP
J: ENTERO
INICIO
MENOR = COLA_ESPERO[0].FALTA_EJECUCION
MIENTRAS (J <> TAMANO(COLA_ESPERO) ) HACER
SI (COLA_ESPERO [J].ptoParalizado + COLA_ESPERO[J].tiempoEsperaActual = I)
(*ES UN PROCESO QUE YA TERMINO DE ESPERAR*)
P = DESENCOLAR(COLA_ESPERA, J)
SI ( P.FALTAEJECUCION < MENOR )
MENOR = P.FALTAEJECUCION
FIN SI
FIN SI
J++
FIN MIENTRAS
RETORNAR MENOR
FIN MENOR_Falta_ejecucion