fisica general ingeniera en sistemas computacionales

Implementacin de Algoritmos de Planificacin de Procesos

Taller de Sistemas Operativos

Integrantes: De La Cruz Cabrera Rebeca Martnez Becerra Moiss Torres vila Mario Alberto Torres Gonzlez Esteban Orlando

Planificacin Primero en Entrar-Primero en Salir (FIFO, First In FirstOut) Primero en entrar, primero en salir (En ingls First in, first out, tambin se usan las siglas FIFO) , es un concepto utilizado en estructuras de datos, contabilidad de costes y teora de colas. Guarda analoga con las personas que esperan en una cola y van siendo atendidas en el orden en que llegaron, es decir, que la primera persona que entra es la primera persona que sale. Tambin se le denomina primero en llegar, primero en ser atendido (del ingls first come, first sorbed o FCFS). En contabilidad FIFO es un mtodo para registrar el valor de un inventario. Su uso es apropiado cuando se cuenta con varios lotes de un mismo producto. Este mtodo presume que el primer producto ingresado en el almacn ser el primero en salir por efectos del inventario. Los FIFO se usan comnmente en circuitos de electrnica para almacenaje y hacer control de flujo. Hablando de hardware un FIFO consiste bsicamente en un conjunto de punteros de lectura/escritura, almacenamiento y lgica de control. El almacenamiento puede ser SRAM, flip-flops, latches o cualquier otra forma adecuada de almacenamiento. Para FIFO de un tamao importante se usa usualmente una SRAM de doble puerto, donde uno de los puertos se usa para la escritura y el otro para la lectura. En hardware, un FIFO se usa para propsitos de sincronizacin. Comportndose como una cola circular y, por lo tanto, contiene dos punteros: Puntero de Lectura / Registro de Direccin de Lectura Puntero de Escritura / Registro de Direccin de Escritura FIFO Vaca Cuando el registro de direccin de lectura alcanza al registro de direccin de escritura, la cola FIFO dispara la seal o bandera Vaco. FIFO Llena Cuando el registro de direccin de escritura alcanza al registro de direccin de lectura, la cola FIFO dispara la seal o bandera.

PLANIFICACIN ROUND ROBIN Round robin es un mtodo 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 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 mtodo para ejecutar diferentes procesos de manera concurrente, para la utilizacin equitativa de los recursos del equipo, es limitando cada proceso a un pequeo perodo (quantum), y luego suspendiendo este proceso para dar oportunidad a otro proceso y as sucesivamente. A esto se le denomina comnmente como Planificacin Round-Robin. Round Robin es un algoritmo de planificacin de procesos simple de implementar, dentro de un sistema operativo se asigna a cada proceso una porcin de tiempo equitativa y ordenada, tratando a todos los procesos con la misma prioridad. En Sistemas operativos, la planificacin Round Robin da un tiempo mximo de uso de CPU a cada proceso, pasado el cual es desalojado y retornado al estado de listo, la lista de procesos se planifica por FIFO, primero llegado, primero atendido. Este algoritmo de planicacin, conocido por Round robin, est diseado especialmente para sistemas de tiempo compartido. Se define un intervalo de tiempo denominado "Quantum", cuya duracin vara segn el sistema. La cola de procesos se estructura como una cola circular. El planicador la recorre asignando un cuanto de tiempo a cada proceso. La organizacin de la cola es FIFO. El Quantum se suele implantar mediante un temporizador que genera una interrupcin cuando se agota el Quantum de tiempo. Si el proceso agota su rfaga de CPU antes de nalizar el Quantum, el planicador asigna la CPU inmediatamente a otro proceso. Este algoritmo tiene un tiempo de espera relativamente grande. Sin embargo, garantiza un reparto de la CPU entre todos los usuarios y arroja tiempos de respuesta buenos.

PRIORIDAD A cada proceso se le asocia una prioridad, a partir de las cual se establece su orden para la planificacin. Para igual prioridad, suele tomarse orden FCFS. Habitualmente, la prioridad de un proceso se almacena como un entero positivo dentro de su PCB, que se inserta en la cola de preparados de acuerdo a ella para facilitar la labor del scheduler (en planificacin de corto plazo). La prioridad se establece inicialmente en funcin de determinados parmetros, como el propietario del proceso, el tipo del proceso (por ejemplo, procesos del sistema, de tiempo real, batch), su tamao, los recursos que requiere, etc. La prioridad inicial puede usarse para planificar a largo plazo. Si la prioridad inicial no cambia durante la ejecucin del proceso y sta se usa para planificar a corto plazo, se obtiene una poltica de prioridades estticas. Un problema de las prioridades estticas es que algunos parmetros, fundamentalmente los referidos al consumo de recursos, y en particular al tiempo de CPU y duracin de sus intervalos, no se conocen a priori, por lo que la prioridad puede no ser indicativa de comportamiento del programa. Otro problema es el riesgo de inanicin para los procesos de prioridad baja, lo que adems puede tener consecuencias para el propio sistema operativo: si un proceso de prioridad alta realiza espera activa para entrar en una seccin crtica ocupada por un proceso de prioridad menor, la seccin crtica nunca se liberar2. En general, resulta ms adecuada una planificacin por prioridades dinmicas. Un proceso se crea con una prioridad base inicial, y su prioridad dinmica se recalcula peridicamente, fundamentalmente de acuerdo al gasto de CPU del proceso. La prioridad de los procesos que ms tiempo de CPU han gastado disminuye en relacin a la prioridad de los procesos que han gastado menos3. Existen fundamentalmente dos formas de ajustar la prioridad: (a) Peridicamente, como por ejemplo UNIX System V, UNIX 3.2BSD y Linux, que ajustan conjuntamente las prioridades de todos los procesos cada cierto tiempo. (b) Aperidicamente, como por ejemplo Windows NT y UNIX SVR4, que aprovecha, la transicin de estado de un proceso para recalcular la prioridad TIEMPO MS CORTO Esta disciplina elige siempre al proceso que le queda menos tiempo de ejecucin estimado para completar su ejecucin; de esta forma aunque un proceso requiera mucho tiempo de ejecucin, a medida que se va ejecutando ira avanzando en la lista de procesos en estado listo hasta llegar a ser el primero. Para realizar esta eleccin, es necesario actualizar el PCB de los procesos a medida que se le asigna tiempo de servicio (activo o bloqueado), lo que supone una mayor sobrecarga adicional. Es una disciplina apropiativa ya que a un proceso activo se le puede retirar la CPU si llega a la lista de procesos en estado listo otro con un tiempo restante de ejecucin estimado menor.

CODIGO:
#include <conio.h> #include <iostream> #include <string.h> #include <cstdio> #include <cstdlib> #define MAX 10 using namespace std; typedef float tipodato; int cantidad; //declaracion de los arreglos string array [5]={"A","B","C","D","E"}; int prioridad [MAX]; int tiempo[MAX]; int prioridadord [MAX]; int tiempoord[MAX]; string arrays [5]={"A","B","C","D","E"}; //typedef nombre; //definicion de la estructur nodo struct nodo { //se declara los campos informacion de la lista tipodato info,info2; string info3; struct nodo *sig; }; //definicion de tipo lista typedef struct nodo *lista; void InicializarList2 (lista &procesos) { procesos=NULL; } //funcion para saber si la losta esta vacia o no int ListaVacia (lista procesos) { if(procesos==NULL) return 1; else return 0; }; void recorridoiterativo2(lista procesos){//se recorre la lista lista nueva; nueva=procesos; while(nueva!=NULL){ cout<<nueva->info<<" "; nueva=nueva->sig; } }; void recorridoiterativo(lista procesos){ lista nueva; nueva=procesos;

while(nueva!=NULL){ cout<<nueva->info2<<" "; nueva=nueva->sig; } }; void InsertarFinalseg (lista &procesos, tipodato X, tipodato y, string h)//se insertan los datos a la lista { lista Q, T; Q=new nodo; Q->info=X; Q->info2=y; Q->info3=h; Q->sig=NULL; if (procesos == NULL) procesos=Q; else { T=procesos; while (T->sig != NULL) T=T->sig; T->sig =Q; } }; void insertaseg(lista &procesos, tipodato x) { lista nueva,t; nueva=new nodo; nueva->info=x; nueva->sig=procesos; procesos=nueva; }; void fifo(lista procesos) { float segu=0; float promedio=0; float prioridad=0; string nombreproceso; lista nueva; nueva=procesos; while(NULL!=nueva) { segu=segu+nueva->info; prioridad=nueva->info2; nombreproceso=nueva->info3; cout<<"tiempo de ejecucion de proceso "<<nombreproceso<<" prioridad "<<prioridad<<" segundos "<<segu<<"\n"; promedio += segu; nueva=nueva->sig; } promedio=promedio/cantidad; cout << "Promedio FIFO " << promedio; cout<<"\n"; };

void mascorto(lista procesos) { float segu=0; float promedio=0; float prioridad; string nombreproceso; lista nueva; nueva=procesos; while(NULL!=nueva) { segu=segu+nueva->info; prioridad=nueva->info2; nombreproceso=nueva->info3; cout<<"tiempo de ejecucion de proceso "<<nombreproceso<<" prioridad "<<prioridad<<" segundos "<<segu<<"\n"; promedio += segu; nueva=nueva->sig; } promedio = promedio/cantidad; cout << "Promedio Mas corto " <<promedio; cout<<"\n"; }; void ordenarprioridad () { int p,z; string n; for (int a=0;a<cantidad;a++) { for(int b=0;b<cantidad-1;b++) { if(prioridadord[b]<prioridadord[b+1] ) { p=prioridadord[b]; prioridadord[b]=prioridadord[b+1]; prioridadord[b+1]=p; n=arrays[b]; arrays[b]=arrays[b+1]; arrays[b+1]=n; z=tiempoord[b]; tiempoord[b]=tiempoord[b+1]; tiempoord[b+1]=z; b++; } } } for (int c=cantidad-1;c>=0;c--) cout<<arrays[c]<<" "; cout<<endl;

for (int g=cantidad-1;g>=0;g--) cout<<prioridadord[g]<<" "; cout<<endl; for (int w=cantidad-1;w>=0;w--) cout<<tiempoord[w]<<" "; cout<<"\n"; }; void ordenarmascorto () { int p,z; string n; for (int a=0;a<cantidad;a++) { for(int b=0;b<cantidad-1;b++) { if(tiempoord[b]>tiempoord[b+1] ) { p=prioridadord[b]; prioridadord[b]=prioridadord[b+1]; prioridadord[b+1]=p; n=arrays[b]; arrays[b]=arrays[b+1]; arrays[b+1]=n; z=tiempoord[b]; tiempoord[b]=tiempoord[b+1]; tiempoord[b+1]=z; b++; } } } for (int c=cantidad-1;c>=0;c--) cout<<arrays[c]<<" "; cout<<endl; for (int g=cantidad-1;g>=0;g--) cout<<prioridadord[g]<<" "; cout<<endl; for (int w=cantidad-1;w>=0;w--) cout<<tiempoord[w]<<" "; cout<<"\n"; }; void datos(int pri,int tie) { cout<<"dame cantidad de procesos\n"; cin>>cantidad; for(int a=0;a<cantidad;a++) { cout<<"dame prioridad del proceso"<<array[a]<<"\n"; cin>>pri; prioridad[a]=pri; prioridadord[a]=pri; cout<<"dame segundos de maquina de proceso "<<array[a]<< "\n";

cin>>tie; tiempo[a]=tie; tiempoord[a]=tie; } }; void round_robin(lista procesos) { float time=0; float tem=0; float quantum; float promedio; float segu=0,prioridad=0; string nombreproceso; for(int a=0;a<cantidad;a++) { quantum=(quantum+tiempoord[a]); } quantum=quantum/cantidad; cout<<"El quantum es : "<<quantum; cout<<"\n"; lista nueva; nueva=procesos; while(NULL!=nueva) { if(nueva->info <=quantum) { segu=segu+nueva->info; prioridad=nueva->info2; nombreproceso=nueva->info3; cout<<"tiempo de ejecucion de proceso "<<nombreproceso<<" prioridad "<<prioridad<<" segundos "<<segu<<"\n"; promedio=segu+promedio; time=time+nueva->info; nueva=nueva->sig; } else { segu=segu+quantum; tem=nueva->info; tem=(tem-quantum); prioridad=nueva->info2; nombreproceso=nueva->info3; InsertarFinalseg(procesos,tem,prioridad,nombreproceso); nueva=nueva->sig; } } promedio=promedio/cantidad; cout<<"promedio es "<<promedio; cout<<"\n"; }; void InsertarAntesX (lista procesos, tipodato Dato,tipodato priorida,string nombreproceso, tipodato Ref) { lista T,Q,X;

int Band = 1; if (ListaVacia(procesos) == 1) cout <<"Lista vacia...no procede insercion"; else Q=procesos; while ((Q->info2 != Ref) && (Band == 1)) { if (Q->sig == NULL) { InsertarFinalseg(procesos,Dato,priorida,nombreproceso); Band = 0; } else { T=Q; Q=Q->sig; } } if (Band == 1) { X=new nodo; X->info=Dato; X->info2=priorida; X->info3=nombreproceso; if ( procesos== Q) { procesos=X; X->sig=Q; } else { T->sig=X; X->sig=Q; } } }; void prioridad_la(lista procesos) { float time=0; float tem=0; float quantum; float promedio; float dat,dat2; float segu=0,prioridad=0; string nombreproceso; for(int a=0;a<cantidad;a++) { quantum=(quantum+tiempoord[a]); } quantum=quantum/cantidad; cout<<"El quantum es : "<<quantum; cout<<"\n"; lista nueva; nueva=procesos;

while(NULL!=nueva) { if(nueva->info <=quantum) { segu=segu+nueva->info; prioridad=nueva->info2; nombreproceso=nueva->info3; cout<<"tiempo de ejecucion de proceso "<<nombreproceso<<" segundos "<<segu<<"\n"; promedio=segu+promedio; time=time+nueva->info; } else { segu=segu+quantum; tem=nueva->info; tem=(tem-quantum); prioridad=nueva->info2; nombreproceso=nueva->info3; dat=nueva->info2; prioridad=prioridad-1; dat2=nueva->info2-2; InsertarAntesX(procesos,tem,prioridad,nombreproceso,dat2); } nueva=nueva->sig; } promedio=promedio/cantidad; cout<<"promedio es: "<<promedio; cout<<"\n"; }; void EliminarPrimero (lista &procesos) { lista Q; if (ListaVacia (procesos)) cout<<""; else { Q=procesos; procesos=Q->sig; delete Q; } }; int main() { int opc ; tipodato dato,ref,dato2,dato3; tipodato numerodeprocesos; int a,b,quantum=0; string dato4; string array [5]={"A","B","C","D","E"}; lista procesos; lista nom; InicializarList2(procesos); do

{ system("cls"); cout << "Selecciona una opcion\n"; cout << " 1) Insertar proceso\n"; cout << " 2) FIFO\n"; cout << " 3) Primero mas corto\n"; cout << " 4) Prioridad\n"; cout << " 5) Round Robin\n"; cout << " 6) SALIR\n"; cin >> opc; switch(opc){ case 1: datos(a,b); break; case 2: for(int a=0;a<20;a++) { EliminarPrimero (procesos); } for(int a=0;a<cantidad;a++) { dato2=tiempo[a]; dato3=prioridad[a]; dato4=array[a]; InsertarFinalseg(procesos,dato2,dato3,dato4); } recorridoiterativo2(procesos); cout<<"\n"; recorridoiterativo(procesos); cout<<"\n"; fifo(procesos); system("pause"); break; case 3: for(int a=0;a<20;a++) { EliminarPrimero (procesos); } ordenarmascorto (); for(int a =0;a<cantidad;a++) { dato3=prioridadord [a]; dato2=tiempoord[a]; dato4=arrays [a]; InsertarFinalseg(procesos,dato2,dato3,dato4); } mascorto(procesos); system("pause"); break; case 4: for(int a=0;a<20;a++) {

EliminarPrimero (procesos); } ordenarprioridad (); for(int a =0;a<cantidad;a++) { dato3=prioridadord [a]; dato2=tiempoord[a]; dato4=arrays [a]; InsertarFinalseg(procesos,dato2,dato3,dato4); } prioridad_la(procesos); system("pause"); break; case 5: for(int a=0;a<20;a++) { EliminarPrimero (procesos); } for(int a =0;a<cantidad;a++) { dato3=prioridadord [a]; dato2=tiempoord[a]; dato4=arrays [a]; InsertarFinalseg(procesos,dato2,dato3,dato4); } round_robin(procesos); system("pause"); } } while(opc != 6); }

CONCLUCION En este trabajo hicimos en cdigo los procesos de FIFO, Mas corto, prioridad y Round Robn, estos procesos ya los vimos en la materia de sistemas operativos, al principio se dificulto hacer el programa debido a que casi no sabamos manejar listas por lo cual se tuvo que investigar, nos tardamos mucho en terminar el programa, mas en prioridad y round robn se termino el programa pero se encontraron algunos problemas que se tuvieron que arreglar. Al final el programa quedo terminado y con este se puede saber con cual proceso es mejor para nuestros datos ingresados, aunque la verdad no utilizamos mucho c lo cual si fue muy difcil el programa.