ProcesosARISO 2

Escola Tècnica Superior d’Enginyeria 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:

http://creativecommons.org/licenses/by-nc-sa/2.5/es/

o envíe una carta a:Creative Commons, 559 Nathan Abbott Way, Stanford,California 94305, USA.

Licencia Creative Commons

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)

Licencia Creative Commons

ProcesosIntroducción

Que es un programa? Estático Fichero ejecutable:

◦ Colección de instrucciones guardadas en disco Cargar en memoria y ejecutar

Programa

Proceso

Que es un proceso? 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

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

Características 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)

Imagen de un proceso

Código

Datos

Pila

Memoria

Imagen en memoria del proceso Código Datos Pila

ProcesosModelo de procesos

Concurrencia de procesos ¿Por que ejecutar simultáneamente varios

procesos?◦ Aprovechar el tiempo de E/S◦ Varios procesadores: paralelismo◦ Compartir recursos entre usuarios

Concurrencia y paralelismo Paralelismo

Concurrencia

Combinados

Proc1

Proc2

Proc3

CPU1

CPU2

CPU3

Proc1 Proc2 Proc3CPU

Proc1 Proc2CPU1

Proc3 Proc4CPU2

Proc5 Proc6CPU3

t

t

t

Estados de un proceso 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

Estados de un proceso

Running

Blocked Ready0

2

1

4

3

5

0 Creación del proceso

1 Planificador escoge este

2 Planificador coge otro

3 Proceso bloqueado E/S

4 E/S disponible

5 Fin del proceso

Process Control Block 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

ProcesosScheduling

Planificación El planificador (scheduler)

◦ Decide cuando cambiar de proceso◦ Decide que proceso ejecutar

Algoritmos de planificación◦ Dependen del entorno del sistema

Proc1 Proc2 Proc3CPU

t

Planificación

Entorno (environment)

•Troughput: Max. trabajos/hora•Turnaround time: Min. tiempo inicio/fin•Utilización CPU: Max. el uso de la CPUBatch•Tiempo de respuesta: responder rápido•Proporcionalidad: Expectativas de usuario

Interactivos

•Deadlines: responder a tiempo•Predictibilidad: funcionamiento continuo

Tiempo Real

Planificación Batch 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

Planificación Batch First Come First Served (FIFO)

◦ No Apropiativo

Prioridades Shortest Job First

◦ No Apropiativo

Shortest Remaining Time Next◦ Apropiativo

Planificación Interactivos 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

ProcesosLinux / UNIX

Creación de procesos 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

Creación de procesosTabla de canales

Tabla de ficheros abiertos

1

1

Inodos

1

1

Proceso1

Creación de procesos

Proceso1

Tabla de canales

Tabla de ficheros abiertos

2

2

Inodos

1

1

Proceso2

Tabla de canales

Creación de procesos int fork()

◦ Valor de retorno: 0 si eres el hijo PID del hijo si eres el padre -1 error

Finalización de procesos 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

Sincronización de procesos 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

Estados de un proceso 2

Running

Blocked Ready

Zombie

Sincronización de procesos 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

Sincronización de procesos 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

Mutación de procesos 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

ejecutableexecl (“/bin/ls”, “ls”, “-la”,null)

Datos de proceso int getpid( )

◦ Devuelve el PID del proceso actual

int getppid()◦ Devuelve el PID del proceso padre

ProcesosEjercicios

Ejercicio: Factorialint 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));

}

Ejercicio: Factorial Solucion 1int 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); }

}

}

Ejercicio: Factorial Solucion 2int 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); wait(NULL);

}

Ejercicio: Factorial Solucion 3int 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); }

}

}

Ejercicio: Factorial Solucion 4int 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);

}

Ejercicio: Factorial Solucion 5int 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);}}

Ejercicio: Factorial Solucion 6int 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);}}

Ejercicio: MaxProcs1int 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)); }

}

Ejercicio: MaxProcs2main( 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"); }}

Ejercicio: Exec 1int 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); } } }

Ejercicio: Exec 2int 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); } } }

Ejercicio: Exec 3int 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");} }}