Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Facultad de Ingeniera
Algoritmos de planificacin
Sistemas Operativos
Trabajo presentado por los Alumnos: John Lpez Suarez Ing. Informtica (2130) Oscar Coloma Castro Ing. Informtica (2130) Madeleine Opazo Cabargas Ing. Civil en computacin (2141) Profesor: Jorge Morris Arredondo De la asignatura:
Sistemas Operativos
Octubre de 2012
ndice de Contenidos:
ndice de Contenidos:........................................................................................... 2 Introduccin:......................................................................................................... 3 ndice de Contenidos:........................................................................................... 2 Introduccin:......................................................................................................... 3
Introduccin:
Este trabajo consta de un anlisis acerca de las caractersticas propias del algoritmo de planificacin conocido como Round Robin, adems de la prioridad de un proceso, los tiempos de llegada y los FCFS. Adems iremos teniendo en cuenta que mientras tenemos un nmero de procesos en memoria al mismo tiempo, la CPU puede ser compartida entre ellos, haciendo ms trabajos en menor tiempo.
Objetivos:
Analizar en profundidad algoritmos de planificacin de procesos simples dentro de un sistema operativo que asigna a cada proceso una porcin de tiempo equitativa y ordenada Entender y dar a conocer toda la informacin acerca del algoritmo de planificacin de procesos Round Robin, FCFS, prioridad; para con esto permitirnos conocer como esta herramienta es de mucha importancia en los sistemas operativos. Conocer, identificar y entender el funcionamiento del algoritmo
Marco terico:
Conceptos: Round Robin: Consta bsicamente de la asignacin de un quantum a cada proceso, como tiempo mximo de uso del procesador. El Round Robin asigna quantums de tiempo a los procesos segn el orden de llegada, normalmente comenzando por el primer elemento de la lista hasta llegar al ltimo y empezando de nuevo desde el primer elemento. Planificacin por prioridad: Una planificacin con prioridades diferentes asignadas a cada proceso, har que estos varen su lugar en la cola de espera. Un proceso en CPU disminuye su prioridad a medida que transcurre el tiempo, para evitar dejar sin atender otros que estn en memoria. Es por eso que los procesos que consumen mayor tiempo en espera reciben prioridades bajas. Por lo tanto cuando un proceso debe
3 Sistemas Operativos, 2012
ser seleccionado, el planificador por prioridades seleccionar aquel proceso que tenga mayor prioridad. Si hay ms de un proceso entonces se deber seguir alguna poltica de seleccin. FCCS: First-Come, First Served. A medida que un proceso pasa al estado listo, este es agregado a la cola de listos. Cuando el proceso que actualmente est ejecutando cesa su ejecucin entonces el proceso ms antiguo en la cola es seleccionado para correr. Adems una vez que el CPU es asignado a un proceso, este lo mantiene hasta que espontneamente lo suelta, ya sea porque el proceso finaliz o por algn requerimiento de entrada o salida. Es por eso que el tiempo de espera bajo esta poltica tiende a ser alto. Adems, tiende a favorecer aquellos procesos que requieren ms tiempo de CPU. Quantum: Es un intervalo de tiempo, cuya duracin vara segn el sistema. Si el quantum es infinito entonces degenera en FCFS. Si el quantum es muy pequeo entonces Round Robin es llamado comparticin de CPU y en teora pareciera que cada proceso tiene su propio procesador corriendo a la velocidad del procesador real.
for(j=1+i; j<n; j++) { if(A[i].tiempollegada> A[j].tiempollegada) // compara los tiempos de llegada { aux =A[i].tiempollegada; // utilizamos auxiliares para ir guardando los datos y no se aux2=A[i].raf; // perdieran para ir comparando posteriormente aux3=A[i].nombre; aux4=A[i].prioridad; A[i].tiempollegada=A[j].tiempollegada; A[i].raf = A[j].raf; A[i].nombre = A[j].nombre; A[i].prioridad=A[j].prioridad; A[j].tiempollegada=aux; A[j].raf=aux2; A[j].nombre=aux3; A[j].prioridad=aux4; } } } } void RoundRobin(proceso A[], int n, int Q, float* timeline) //function que ejecuta Round Robin { int i; for(i=0;i<n;i++) { if(A[i].raf>=Q && A[i].raf!=0) { cout<<"JOB "<<A[i].nombre<<" : "<<*timeline<<" - "<<*timeline + A[i].raf - (A[i].raf-Q)<<endl; //muestra los algoritmos de round robin *timeline=*timeline+A[i].raf - (A[i].raf-Q); A[i].raf=A[i].raf - Q; } else { if(A[i].raf<Q && A[i].raf!=0)
5
{
Sistemas Operativos, 2012
cout<<"JOB "<<A[i].nombre<<" : "<<*timeline<<" - "<<*timeline + A[i].raf <<endl; *timeline=*timeline+A[i].raf ; A[i].raf=0; } } } } void fcfs(proceso A[], int n, int Q, float* timeline) { int i; float sum=0; for(i=0;i<n;i++) { cout<<"JOB "<<A[i].nombre<<" : "<<*timeline<<" - "<<*timeline + A[i].raf<<endl; *timeline=*timeline+A[i].raf; } } void Prioridad(proceso A[], int n, int Q, float & timeline) { int i; int j; float aux; int P=999; int C=0; for(i=0;i<n;i++) { j=i; if(A[i].raf!=0 && C!=1) { cout<<"JOB "<<A[i].nombre<<" : "<<timeline<<" - "<<timeline + A[i].raf<<endl; timeline=timeline+A[i].raf; A[i].raf=0; C=1; } for(i=0;i<n;i++) { if(A[i].prioridad<P && A[i].raf!=0 && A[i].tiempollegada<timeline) { P = A[i].prioridad;
6 Sistemas Operativos, 2012
} } for(i=0;i<n;i++) { if(A[i].prioridad == P && A[i].raf!=0) { cout<<"JOB "<<A[i].nombre<<timeline<<" - "<<timeline + A[i].raf<<endl; timeline=timeline+A[i].raf; A[i].raf=0; } } i=j; P=999; } }
int main(int argc, char *argv[]) { int Q,n,i,procesopendiente; proceso A[10]; float timeline; procesopendiente=0; cout<<"-----------------------------"<<endl; cout<<" Trabajo Sistemas Operativos "<<endl; cout<<"-----------------------------"<<endl<<endl<<endl; cout<<"Ingrese cantidad de procesos(maximo 5): "; cin>>n; cout<<"Ingrese Quantum: "; cin>>Q; cout<<endl; A[0].nombre A[1].nombre A[2].nombre A[3].nombre A[4].nombre A[0].raf A[1].raf A[2].raf A[3].raf
7
= = = = =
= = = =
3; 5; 6; 2;
Sistemas Operativos, 2012
A[4].raf = 10; A[0].prioridad A[1].prioridad A[2].prioridad A[3].prioridad A[4].prioridad = = = = = 5; 9; 10; 0; 4; = 1.8; //los tiempos de llegada van a estar predefinidos, por = = = = 1.5; // de la cantidad de procesos que ingrese el usuario. 1.3; 4.0; 8.0;
for(i=0;i<n;i++) { cout<<"JOB "<<A[i].nombre<<" : "<<A[i].tiempollegada<<endl; //muestra los tiempos de llegada } // segun n o cantidad de cout<<endl; // procesos ingresados. ordenar(A,n); //enviara los tiempos de llegada segun cantidad de procesos a la function ordenar, // para ordenarlos de menor a mayor. for(i=0;i<n;i++) { cout<<"JOB "<<A[i].nombre<<" : "<<A[i].tiempollegada<<endl; //ahora los mostrar ordenados } // los tiempos de llegada. cout<<endl; timeline=A[0].tiempollegada; if(n>0 && n<=5) { cout<<"Primer algoritmo: Round Robin"<<endl<<endl; RoundRobin(A,n,Q,&timeline); //envia tiempo de llegada, cant. De procesos, quantum y for(i=0;i<n;i++) //timeline a function RoundRobin. { if(A[i].raf!=0) { procesopendiente++; } } if(procesopendiente>0) { cout<<endl;
8 Sistemas Operativos, 2012
cout<<"Los procesos pendientes han pasado al segundo algoritmo"<<endl<<endl; system("PAUSE"); cout<<"Segundo Algoritmo: Round Robin"<<endl<<endl; RoundRobin(A,n,Q,&timeline); procesopendiente=0; for(i=0;i<n;i++) { if(A[i].raf!=0) { procesopendiente++; } } if(procesopendiente>0) { cout<<endl; cout<<"Los procesos pendientes han pasado al tercer algoritmo"<<endl<<endl; system("PAUSE"); cout<<"Tercer Algoritmo: PRIORIDAD"<<endl<<endl; Prioridad(A,n,Q,timeline); procesopendiente=0; for(i=0;i<n;i++) { if(A[i].raf!=0) { procesopendiente++; } } if(procesopendiente>0) { cout<<endl; cout<<"Los procesos pendientes han pasado al cuarto algoritmo"<<endl<<endl; system("PAUSE"); cout<<"Cuarto Algoritmo: FCFS"<<endl<<endl; fcfs(A,n,Q,&timeline); procesopendiente=0; } } } } else //si el usuario ingresa mas de 5 procesos entregar este mensaje { cout<<"La cantidad de procesos no es la adecuada, intentelo nuevamente."<<endl; i=-1; }
9 Sistemas Operativos, 2012
Conclusin
Dentro de lo investigado pudimos concluir que la planificacin de un procesador es una de las partes ms importantes dentro del anlisis de un sistema operativo. Gracias a este anlisis mediante el algoritmo realizado descubrimos la gran importancia de la planificacin de un procesador, que por cierto es la base de los sistemas operativos para la multiprogramacin.
Bibliografa http://ldc.usb.ve/~spd/Docencia/ci-3821/Tema4/node8.html
10