ARISO 2 Escola Tècnica Superior dEnginyeria de Telecomunicació de Barcelona (Universitat Politècnica de Catalunya)

Esta obra está bajo una licencia Reconocimiento-No comercial-Compartir bajo la misma licencia 2.5 España de Creative Commons. Para ver una copia de esta licencia, visite: o envíe una carta a: Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.

Eres libre de: copiar, distribuir y comunicar públicamente la obra hacer obras derivadas Bajo las condiciones siguientes: Atribución. Debes reconocer la autoría de la obra en los términos especificados por el propio autor o licenciante. No comercial. No puedes utilizar esta obra para fines comerciales. Licenciamiento Recíproco. Si alteras, transformas o creas una obra a partir de esta obra, solo podrás distribuir la obra resultante bajo una licencia igual a ésta. Al reutilizar o distribuir la obra, tienes que dejar bien claro los términos de la licencia de esta obra. Alguna de estas condiciones puede no aplicarse si se obtiene el permiso del titular de los derechos de autor Advertencia: Los derechos derivados de usos legítimos u otras limitaciones reconocidas por ley no se ven afectados por lo anterior. Esto es un resumen legible por humanos del texto legal (la licencia completa)

Introducción

Estático Fichero ejecutable: Colección de instrucciones guardadas en disco Cargar en memoria y ejecutar ProgramaProceso

Unidad de asignación de recursos que proporciona el SO (memoria, flujos, canales) La cantidad de recursos de un proceso es dinámica (se asignan/se liberan) Los procesos se gestionan mediante llamadas a sistema Crear/destruir/modificar/consultar

Process Identifier (PID) User I/O Channels Signals / Exceptions Priority and Scheduling Process Control Block (PCB)

Se identifican mediante un PID (Process IDentifier) Único en el sistema Constante durante toda la vida del proceso Están asociados a un usuario Tendrá acceso a los recursos en función del usuario Se puede cambiar de usuario Dispone de canales para realizar la E/S Gestión de excepciones y eventos Tienen prioridades, usadas para planificar Esta información se almacena en el PCB (Process Control Block)

Código Datos Pila Memoria Imagen en memoria del proceso Código Datos Pila

Modelo de procesos

¿Por que ejecutar simultáneamente varios procesos? Aprovechar el tiempo de E/S Varios procesadores: paralelismo Compartir recursos entre usuarios

Paralelismo Concurrencia Combinados Proc1 Proc2 Proc3 CPU1 CPU2 CPU3 Proc1Proc2Proc3 CPU Proc1Proc2 CPU1 Proc3Proc4 CPU2 Proc5Proc6 CPU3 t t t

Creación de un proceso Inicialización del sistema Llamada a sistema: creación de proceso Mutación de un proceso Finalización de un proceso Voluntario Normal exit Error exit Involuntario Fatal error Killed

Running Blocked Ready Creación del proceso 1Planificador escoge este 2Planificador coge otro 3Proceso bloqueado E/S 4E/S disponible 5Fin del proceso

1 Process Table n PCBs Process Management Registers Program Counter Program Status Word Stack pointer Process state Priority Scheduling parameters Process ID Parent Process Signals Init Time CPU Time Used Memory Management Pointer to code segment Pointer to data segment Pointer to stack segment File Management Root directory Working directory File descriptors User ID Group ID

Scheduling

El planificador (scheduler) Decide cuando cambiar de proceso Decide que proceso ejecutar Algoritmos de planificación Dependen del entorno del sistema Proc1Proc2Proc3 CPU t

Entorno (environment) Troughput: Max. trabajos/hora Turnaround time: Min. tiempo inicio/fin Utilización CPU: Max. el uso de la CPU Batch Tiempo de respuesta: responder rápido Proporcionalidad: Expectativas de usuario Interactivos Deadlines: responder a tiempo Predictibilidad: funcionamiento continuo Tiempo Real

Planificacor no apropiativo (nonpreemptive) El SO no expulsa nunca al proceso de la CPU El proceso abandona voluntariamente la CPU Planificador apropiativo (preemptive) El SO puede decidir expulsar a un proceso de la CPU

First Come First Served (FIFO) No ApropiativoPrioridades Shortest Job First No Apropiativo Shortest Remaining Time Next Apropiativo

Round-Robin Scheduling ( quantum ) Priority Scheduling ( estática vs dinámica ) Multilevel Queues Lottery Scheduling Prioridad 4 Prioridad 3 Prioridad 2 Prioridad 1 P1 P2 P3 P4 P5 P6 P8 P7

Linux / UNIX

fork() Crea un nuevo proceso idéntico Copia código Copia datos Copia pila PCB nuevo en la Process Table Nuevo PID Nuevo Parent Process Código Datos Pila Código Datos Pila Código Datos Pila

Tabla de canales Tabla de ficheros abiertos 1 1 Inodos 1 1 Proceso1

Tabla de canales Tabla de ficheros abiertos 2 2 Inodos 1 1 Proceso2 Tabla de canales

int fork() Valor de retorno: 0 si eres el hijo PID del hijo si eres el padre -1 error

exit(int status) Finaliza un proceso Devuelve status al proceso padre Que hace el SO: Liberar memoria (código, pila, datos) Cerrar y destruir la tabla de canales Decrementar # links de la TFA

int wait(int *status) Espera a la finalización de un HIJO cualquiera Devuelve: PID del hijo que finaliza -1 en caso de error Status contendrá el valor del exit del hijo

Running Blocked Ready Zombie

int wait(int *status) hijo zombie Devuelve PID, status Finaliza el proceso hijo hijo zombie hijo(s) vivo(s) Bloqueo hasta que un hijo acabe hijo(s) vivo(s) Retorna -1

int waitpid (int pid, int *stat, int flags) Espera a la finalización de un HIJO en concreto Devuelve: PID del hijo que finaliza -1 en caso de error Status contendrá el valor del exit del hijo Flags modifican el comportamiento de la función

int execl(char *path, char *arg0,…, null ) int execv(char *path, char *arg[] ) Ejecuta un programa nuevo Sustituye: Código, Datos y Pila Path ruta al fichero a ejecutar (/bin/ls) Arg lista de argumentos, comienzan por el ejecutable execl (/bin/ls, ls, -la,null)

int getpid( ) Devuelve el PID del proceso actual int getppid() Devuelve el PID del proceso padre

Ejercicios

int factorial(int num) { int tmp=1; while (num>1) { tmp = tmp * num; num--; } return(tmp); } void hijo(int inicio) { for (; inicio < 13; inicio +=2) printf("Factorial de %d es %d\n", inicio, factorial(inicio)); }

int main( void ) { int pid1,pid2; pid1=fork(); if (pid1==0) // Estoy en el hijo1 { hijo(0); exit(0); } else {// Estoy en el padre pid2=fork(); if (pid2==0) // Estoy en el hijo2 {hijo(1); exit(1); } else { wait(NULL); wait(NULL); } }

int main( void ) { switch(fork()) { case -1: { printf("Error al crear hijo"); exit(0); break;} case 0: { hijo(0); exit(0); break;} } switch(fork()) { case -1: { printf("Error al crear hijo"); exit(0); break;} case 0: { hijo(1); exit(1); break;} } wait(NULL); }

int main( void ) { int pid1,pid2; pid1=fork(); if (pid1==0) // Estoy en el hijo1 { hijo(0); /*exit(0);*/ } else {// Estoy en el padre pid2=fork(); if (pid2==0) // Estoy en el hijo2 {hijo(1); /*exit(0);*/ } else { wait(NULL); wait(NULL); } }

int main( void ) { int pid1,pid2; int val1,val2; pid1=fork(); if (pid1==0) // Estoy en el hijo1 { hijo(0); exit(1); } else {// Estoy en el padre pid2=fork(); if (pid2==0) // Estoy en el hijo2 {hijo(1); exit(2); } } waitpid(pid1,&val1,0); waitpid(pid2,&val2,0); printf("Pid:%d Val:%d\nPid:%d Val:%d\n", pid1,val1>>8,pid2,val2>>8); }

int main( void ) { int pid1,val1; pid1=fork(); if (pid1==0) { pid1=fork(); if (pid1==0) {hijo(1); exit(2); } hijo(0); waitpid(pid1,&val1,0); } else {waitpid(pid1,&val1,0);} }

int main( void ) { int pid1,val1; pid1=fork(); if (pid1==0) { pid1=fork(); if (pid1==0) {hijo(1); exit(2); } waitpid(pid1,&val1,0); hijo(0); } else {waitpid(pid1,&val1,0);} }

int main( void ) {int pid1,v1,fin=0,cuantos=0; while(fin==0) { pid1=fork(); switch(pid1) { case -1: fin=1; break; case 0: for(cuantos=0;cuantos<1000;cuantos++) {fin=cuantos*(cuantos+cuantos)*(cuantos*cuantos);} printf("H Fin: %d\n",getpid()); exit(1); break; default:printf("P New: %d\n",pid1); cuantos++; break; } for(fin=0;fin<cuantos;fin++) { printf("P Fin PID=%d\n",wait(NULL)); } }

main( void ) { int i,j,vpid; vpid=fork(); if (vpid==0) { for(i=1;i<20;i++) { for(j=0;j<35000;j++) {vpid=(j*vpid)/i;} printf("Padre:%d\n",getppid()); } else { for(i=1;i<5;i++) { for(j=0;j<35000;j++) {vpid=(j*vpid)/i;} } printf("Fin padre\n"); }

int main( void ) { int pid1,pid2,v1,v2; pid1=fork(); if (pid1==0) { execl("/bin/ls","ls","-la",NULL); } else { pid2=fork(); if (pid2==0) { execl("/bin/cat","cat","/etc/passwd",NULL); } else {wait(NULL); wait(NULL); } } }

int main( int argc, char **argv ) { int pid1,pid2,v1,v2; if (argc != 3) {printf("Error de parametros\n"); exit(1);} pid1=fork(); if (pid1==0) { execl("/bin/grep","grep",argv[1],"/etc/passwd",NULL); } else { pid2=fork(); if (pid2==0) { execl("/bin/grep","grep",argv[2],"/etc/passwd",NULL); } else { waitpid(pid1,&v1,0); waitpid(pid2,&v2,0); printf("Hijo 1: %d\n",v1>>8); printf("hijo 2: %d\n",v2>>8); }

int main( void ) { int pid1,pid2,v1,v2; pid1=fork(); if (pid1==0) { execl("/bin/ls","ls","-la",NULL); } else { wait(NULL); pid2=fork(); if (pid2==0) { execl("/bin/cat","cat","/etc/passwd",NULL); } else {wait(NULL); printf("Padre acaba\n");} }