Sistemas Operativos

A continuación pongo en consideración una pequeña simulación del algoritmo “primero el trabajo más corto” (shortest – job - first).
La aplicación esta desarrollada en Java bajo el IDE NetBeans 6.0 y permite crear procesos(en realidad son solo objetos no hilos) que ocuparán cada uno un tiempo de ejecución o uso de CPU determinado por el usuario.

Esto funciona de la siguiente manera al establecer cuantos procesos se realizarán el usuario deberá especificar que tiempo tardará cada uno en terminar, para luego la aplicación planifique su ejecución empezando por el más pequeño.

Una vez encontrado el orden exacto cada proceso ocupará el thread(hilo) central de la aplicación haciéndola detener para que nadie pueda ocuparlo mientras él se ejecuta, además cabe recalcar que por ser una demostración se estima el tiempo en segundos(el hacerlo unidades menores no daría mucha idea de lo que sucede). Luego abandonará el control del hilo y pasará al siguiente. Al terminar todos los procesos la aplicación también terminará.

Puedo decir que este algoritmo presenta varias ventajas pues al realizar los procesos con menor tiempo primero el tiempo de espera disminuye considerablemente aunque en una situación real la única dificultad es el cálculo de la ráfaga de CPU que como mencioné en un post anterior es aproximada.

El programa se puede descargar desde aqui

Saludos,

En post anteriores se detalló el funcionamiento de esta planificación. La misma que consistía en una estructura FIFO de forma circular en donde cada proceso ocuparía la cpu dependiendo de un determinado tiempo conocido como “quantum”.

La aplicación realizada bajo el entorno java simula este algoritmo de la siguiente manera.
Lo primero que se realiza es solicitar la cantidad de procesos que se utilizarán la cpu y de la misma manera el tiempo quantum que podrá estar cada uno dentro, este tiempo se lo deberá dar en segundos(sin fracciones).

A continuación el programa generará con un proceso aleatorio los intervalos de tiempo que cada procesa necesita, para demostración esta controlado que no sea ni cero ni un valor mayor a 11(solo para no dejar la máquina trabajando mucho tiempo).

Una vez determinados los procesos serán almacenados en una estructura dinámica en este caso un ArrayList de donde serán extraídos en orden para que pasen a ocupar la CPU.
Algo que vale notar es que cuando un proceso ingresa a la cpu, el programa detiene el Thread principal de la aplicación el número de segundos que indique el quantum, por es mejor no colocar intervalos grandes(mayores 10). Esto da la apariencia d que si fuera un proceso real se estaría ejecutando.

Y finalmente cumplidos los tiempos de cada proceso son eliminados de la estructura hasta que esta quede vacía y se da por terminada la aplicación.

Es importante enfatizar que el problema de este Algoritmo es que el tiempo de entrega de un proceso dependerá mucho del tiempo quantum y en menor cantidad de su tiempo necesario.
Saludos,

La planificación de uso de la CPU, es la base de todo sistema operativo, ya que una planificación correcta permitirá un uso máximo, lo que causaría un rendimiento “optimo”.
Pero, como hace un Sistema Operativo para planificar sus procesos???

Partamos pues de que un proceso necesita una cantidad de tiempo para ser realizado(cambiar de estado a terminado), pero como un mismo proceso no puede ocupar la cpu hasta que termine se permitirá a cada proceso un tiempo de uso de cpu, también conocido como “ráfaga de la cpu”, y para esto se almacenara toda la información del proceso, (como su estado, tiempo de espera, entre otros) dentro de un “bloque de control del proceso” (PCB) que determinará todo el estado de un proceso.

Pero, como “sabe”(literalmente) el Sistema Operativo que proceso es el correcto o más necesario para que utilice la cpu???

Pues a decir verdad cada sistema operativo implementa criterios de planificación, basados en algoritmos que intentan que la cpu no este ociosa(en tiempo de espera Ej. E/S)

Entre los criterios que se emplean para la planificación puedo mencionar:

• Utilización de la CPU.- Tenerla tan ocupada como sea posible. Esto es un 40% en Sistemas ligeros y 90% en sistemas pesados.

• Rendimiento.- Calculado mediante el número de procesos que es capaz de terminar en una unidad de tiempo.

• Tiempo de Entrega.- Se considera como el tiempo desde que un proceso inicia hasta que termina.

• Tiempo de espera.- Lo considero como la suma de periodos de tiempo en la cola de listos.

• Tiempo de Respuesta.- Es el tiempo que se requiere para que un proceso empiece a responder y no el tiempo para dicha respuesta.

Siguiendo estos criterios, se deduce que lo más deseable es que aumenten los dos primeros puntos(Utilización - rendimiento) y disminuyan todos los demás.

Para conseguir este fin se utilizan algoritmos que distribuyen o planifican procesos, por ahora solo los enunciaré para en un próximo post detallarlos:

• FCFS
• SJF
• Procesos por Prioridad
• RR

Saludos,

//colas por divison
//sistemas operativos

import java.io.*;

public class Colas {
public static class ClaseColas { // Declaracion de la clase de Colas
static int max=10; // Numero maximo de la Cola
static int cola[]= new int[max]; // Declaracion del arreglo
static int frente, fin; // Indicadores de inicio y fin de la Cola
static int subir, bajar; //subir y bajar proceso
static int prio=0;// prioridad

ClaseColas() { // Constructor que inicializa el frente y el final de la Cola
frente=0; fin=0;
System.out.println(”Cola inicializada !!!”);
}

public static void Insertar(int dato) {
if(fin==max) { // Esta llena la Cola?
System.out.println(”\nCola llena !!!”);
return;
}
cola[fin++]=dato;
System.out.println(”Dato insertado !!!”);
}

//
public static void Mostrar() {
int i=0;
System.out.println(”\n\n<<>>”);
if(cola==max) System.out.println(”\nCola vacia !!!”);
for(i=cola; i<max; i++) {
cola=cola(i-1)/2;
Prio= frente + cola(i-1)/2;
System.out.println(”cola[”+i+”]=”+” “+cola[i]);
}

public static void Subir() {
int i=0;
System.out.println(”\n\n<<>>”);
if(frente==fin) System.out.println(”\nCola vacia !!!”);
for(i=frente; i<fin; i++) {
System.out.println(”cola[”+i+”]=”+” “+cola[i]);
}

System.out.println(”\nFrente= “+frente);
System.out.println(”Final = “+fin);
System.out.println(”Max = “+max);
}
}

static ClaseColas Cola=new ClaseColas(); // Declaracion del objeto Cola

// Funcion principal
public static void main(String args[]) throws IOException {
int op=0;
do {
System.out.println(”\n\n<<>>”);
System.out.println(”1.- Altas”);
System.out.print(”Opcion? —> “);
op=getInt();

switch(op) {
case 1 : Altas(); break;

case 3 : Cola.Mostrar(); break;
}
}while(op!=0);
}

public static void Altas() throws IOException {
int elemento=0;
System.out.println(”\n\n<<>>”);
System.out.print(”Elemento a insertar? —> “);
elemento=getInt();
Cola.Insertar(elemento); // Invocar el metodo Insertar del objeto Cola
}

}

Integrantes:

Juan Pablo Arrobo
Andrea Espinosa
Jhoanna Simancas

#include <stdlib.h>
#include <iostream.h>

struct estudiante {
char nombre [20];
int edad;
estudiante *enlace;
};

estudiante *cabeza=NULL;
estudiante *cola=NULL;

void insertar(char *nombre, int edad);
void presentarlista();

int main()
{
char continua = ’s’;
char nombre [20];
int edad;
while (continua == ’s’){
cout<< “Ingrese el nombre y la edad del estudiante”<> nombre >> edad;
insertar(nombre, edad);
cout<> continua;
}

presentarlista();
system(”PAUSE”);
return 0;
}

void insertar(char *nombre, int edad) {
if (cabeza == NULL) { // Si no hay ningún nodo en la lista
cabeza = new estudiante;
cola = cabeza;
}
else { // Si ya hay nodos en la lista
cola->enlace = new estudiante;
cola = cola->enlace;
}
// strcpy (cola->nombre, nombre);
cola->edad = edad;
cola->enlace = NULL;
}

// Rutina que presenta la lista ingresada
void presentarlista(){
estudiante *recorrer=cabeza; // variable auxiliar
while (recorrer != NULL) { // si aun hay elementos en la lista
// presentar el nombre y la edad
cout<< “Nombre: “<nombre << ” edad: “<edad <enlace;
}
}

Integrantes:
Leonardo Saldaña
John Iñiguez
Israel Rodriguez

Paralelo “A”

Algoritmo de Planificación SJF en C

Integrantes
Cabrera Karla
Pulla Cinthia
Ramos Jammil

Round robin es un método para seleccionar todos los elementos en un grupo de manera equitativa y en un orden racional, normalmente comenzando por el primer elemento de la lista hasta llegar al último y empezando de nuevo desde el primer elemento. El planeamiento Round Robin es tan simple como fácil de implementar, y está libre de inanición.
El nombre del algoritmo viene del principio de Round-Roubin conocido de otros campos, donde cada persona toma una parte de un algo compartido en cantidades parejas.
Una forma sencilla de entender el round robin es imaginar una secuencia para “tomar turnos”. En operaciones computacionales, un método para ejecutar diferentes procesos de manera concurrente, para la utilización equitativa de los recursos del equipo, es limitando cada proceso a un pequeño periodo de tiempo (quantum), y luego suspendiendo éste proceso para dar oportunidad a otro proceso y así sucesivamente. A esto se le denomina comúnmente como Planificación Round-Robin.
Nosotros hemos implementado este algoritmo en el lenguaje de programación Java, en el entorno de desarrollo integrado (IDE) NetBeans 6.0, pero este no es inconveniente porque el programa puede ser ejecutado por versiones anteriores a esta…

El proyecto esta compuesto por dos clases una que se llama “Proceso”, la cual va a simular un proceso como un Objeto con las siguientes propiedades, nombre, ID, estado, ráfaga de CPU o tiempo de ejecución y otra clase llamada “RoundRobin” la cual va a ser la clase principal desde la cual se va a ejecutar el programa… Este programa trabaja de una forma dinámica, como entrada principal le va a pedir al usuario que ingrese cuantos procesos quiere ejecutar para realizar la prueba, y como una segunda entrada le va a pedir un valor para el quantum, los tiempos van ha ser generados de forma aleatoria con números comprendidos entre 0 y 100 para que la prueba se realice más rápido, pero queda una opción comentada en la parte del código para que si el usuario quiere ingresar los tiempos de manera manual lo pueda hacer…

Este es el resultado que obtendremos probando el ejercicio del libro…

Código de la Aplicación

Por:
Christian Mora
Argenis Riofrío
Paralelo: “B”

Se ha pedido que realicen la simulación de los algoritmos de planificación con el objetivo de poner en práctica la teoría aprendida en clases. Para lo cual deberán postear como realizaron la simulación y colocar el código fuente y ejecutable del mismo. Al final del post colocar  el nombre de los integrantes y el paralelo al que pertenecen.