Post on 12-Jan-2015
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");} }}