Uploaded on

Procesos

Procesos

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
7,599
On Slideshare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
266
Comments
0
Likes
0

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Multiprogramación Procesos Cecilia Hernández 2007-1
  • 2. Terminología
    • Multiprogramación
      • Ejecutar multiples programas al mismo tiempo
      • Requiere multiplexar la CPU
        • Tranferencia de control entre programas en ejecución mediante
          • Cambio de contexto
    • Proceso : Programa en ejecución
    gcc firefox word firefox tiempo
  • 3. Procesos
    • Abstracción de SO de programa en ejecución
    • Asociado a un espacio de direccionamiento
    • Adelanto, múltiples hebras de control comparten mismo espacio de direccionamiento
    código (text segment) Datos estáticos (data segment) heap (mem dinámica) stack (mem dinámica) Espacio de direccionamiento SP PC
  • 4. Multiplexando CPU en el tiempo
    • SO mantiene estructuras de datos para identificar procesos
      • PCB (Process Control Block)
        • SO matiene un PCB por cada proceso que está ejecutando en el sistema (para cuando no están usando CPU)
    • SO ejecuta cambio de contexto para quitar y dar CPU a par de procesos
      • Salva estado de proceso que sale de CPU en PCB de proceso
      • Recupera estado de PCB de proceso que entra a CPU para luego ejecutarlo
  • 5. PCB
    • Estructura de datos con muchos campos
      • Identificador de proceso (PID)
      • Estado de ejecución (Listo, en ejecución, bloqueado)
      • PC, SP, registros
      • Información de administración de memoria
      • Usuario al que pertenece
      • Prioridad en ejecución
      • Información para administración
    • En linux
      • Definida en task_struct (include/linux/sched.h)
        • Posee muchos más campos de los mencionados arriba
  • 6. Estados de los procesos En ejecución listo Bloqueado Interrupción Sale de CPU Se despacha a CPU interrupción (completa E/S) Espera E/S
  • 7. Colas de procesos
    • SO mantiene diversas colas para representar los procesos en el sistema
      • Cola de procesos listos: Procesos que están en condiciones de ejecutarse esperando por entrega de CPU
      • Cola de procesos bloqueados: Procesos que esperan por alguna condición para estar listos para ejecutarse
    • Cuando un proceso cambia de estado, su PCB se desenlaza de una cola para enlazarse a otra
  • 8. Colas de Procesos
    • Hay muchas colas de espera, una por cada tipo de espera (dispositivo E/S específico, red, etc)
    Ptr head Ptr tail firefox pcb emacs pcb gcc pcb cat pcb firefox pcb Ptr head Ptr tail Encabezado cola espera Encabezado cola listos
  • 9. Cambio de contexto
    • Proceso mediante el cual se cambia de un proceso en ejecución a otro
    • Proceso A entra en kernel
      • Producto de llamada a sistema, interrupción o excepción
    • El Planificador del SO se ejecuta
      • Es tiempo de cambio de contexto?
      • Si, sacar de cola de listos siguiente proceso a ejecutar. Proceso B
    • Rutina en assembly intercambia información de estado del HW
      • Salva el estado de proceso A en su PCB
      • Restaura estado de proceso B de su PCB
      • Salvar y recuperar estado, incluye CPU y adm de memoria virtual y resets de caches
    • Ejecuta proceso B
    • OS retorna a modo usuario
  • 10. Cambio de contexto en linux
    • Para cambio relacionado con la memoria
      • Include/asm/mmu_context.h
    • Para cambio de recursos de CPU
      • include/asm/system.h
        • Aqui se define una macro llamada switch_to(prev,next,last)
          • Para mayor información de los detalles de esta macro revisar
          • Bovet Daniel P., Sesati Marco, “Understanding the Linux Kernel” (2nd Edition). O'Reilly Media, Inc. 2002
  • 11. Procesos en Unix
    • Como crear aplicaciones usando procesos?
    • Usando Llamadas a sistema
      • Fork : crea un nuevo proceso
      • Exec : ejecuta un programa en proceso (varios formatos disponibles)
      • Kill : envia señales a procesos
        • Pueden ser de término o no
      • Wait : espera por proceso hasta que termina
        • Varios formatos
  • 12. Creación de procesos en Unix
    • Usando llamada a sistema fork()
    • Básicamente, copia proceso padre
      • Proceso hijo obtiene un espacio de direccionamiento igual al del padre, pero es independiente
      • Proceso hijo hereda todos los archivos abiertos del padre
    • Fork se comporta diferente a cualquier llamado
      • Retorna dos veces
        • Retorna el pid del hijo al padre
        • Retorna 0 al hijo
  • 13. Ejemplo fork
    • #include <unistd.h>
    • int value = 5;
    • int main () {
    • pid_t pid ;
    • value = 7;
    • pid = fork();
    • if (pid == 0) { // hijo
    • value += 15;
    • }
    • else { // Padre
    • wait (NULL); // espera a que hijo termine
    • printf(&quot;PADRE: value = %d &quot;,value );
    • }
    • }
    Qué valor es impreso en pantalla?
  • 14. Fork versus exec
    • Fork()
      • Sólo permite crear nuevo proceso copiando al padre
      • Como hacer que el hijo ejecute algo diferente
        • Usando exec()
        • Ejemplo
          • Int exec( char *prog, char **argv)
    • Exec()
      • Detiene proceso actual
      • Carga programa ‘prog’ en espacio de direccionamiento
      • Inicializa nuevo contexto, args para ‘prog’
      • Pone PCB proceso en cola de listos
      • NO CREA nuevo proceso, solo cambia lo que esta en espacio de direcciomiento
  • 15. Variaciones de exec()
    • int ret;
    • ret = execl (&quot;/bin/ls&quot;, &quot;ls&quot;, &quot;-1&quot;, (char *)0);
    • char *env[] = { &quot;HOME=/usr/home&quot;, &quot;LOGNAME=home&quot;, (char *)0 };
    • ret = execle (&quot;/bin/ls&quot;, &quot;ls&quot;, &quot;-l&quot;, (char *)0, env);
    • ret = execlp (&quot;ls&quot;, &quot;ls&quot;, &quot;-l&quot;, (char *)0)
    • char *cmd[] = { &quot;ls&quot;, &quot;-l&quot;, (char *)0 };
    • ret = execv (&quot;/bin/ls&quot;, cmd);
    • char *cmd[] = { &quot;ls&quot;, &quot;-l&quot;, (char *)0 };
    • ret = execvp (&quot;ls&quot;, cmd);
  • 16. Variaciones wait() pid_t wait(int *status) pid_t waitpid(pid_t, int *status, int options)
  • 17. Shell Unix int main(int argc, char **argv) { while (1) { char *cmd = get_next_command(); int child_pid = fork(); if (child_pid == 0) { exec(cmd); // vea variaciones de exec panic(“exec failed!”); } else { int st; waitpid(child_pid, &st, WIFEXITED(st) ); } } }
  • 18. Comunicación entre procesos
    • Usando señales SIGUSR1, SIGUSR2
      • Ejemplo sigusuario.c
    • Usando Pipes
      • Permite la comunicación en un sentido entre dos procesos
        • Int pipe(int fds[2])
  • 19. Pipe en un proceso pipe Proceso de usuario write fd read fd -> Flujo de datos -> kernel
  • 20. Código que representa pipe en un proceso
    • #include <unistd.h>
    • main() {
    • int pipefd[2], n;
    • char buff[100];
    • if(pipe(pipefd) < 0)
    • cout<<“error con pipe”<<endl;
    • cout<<“read fd = %d, write fd = %d ”, pipefd[0], pipefd[1]);
    • if(write(pipefd[1], “hola yo mismo ”, 14) != 14)
    • cerr<<“error con write”<<endl;
    • if ((n = read(pipefd[0], buff, sizeof(buff))) <=0 )
    • cerr<<“error con read”<<endl;
    • write(1, buff, n); // 1 por salida estandar stdout
    • }
  • 21. Pipe en proceso padre/hijo después de fork pipe -> Flujo de datos -> write fd read fd write fd read fd fork Proceso padre Proceso hijo kernel
  • 22. Comunicando padre con hijo en una dirección pipe -> Flujo de datos -> write fd read fd write fd read fd fork Proceso padre Proceso hijo kernel
  • 23. Usando dup2
    • int dup2(int oldfd, int newfd);
      • Permite duplicar oldfd creado con otro especificado en newfd, cerrando newfd primero si es necesario
  • 24. Ejemplo usando dup2
    • int main(int argc, char **argv)
    • {
    • int pipefd[2];
    • int pid;
    • pipe(pipefd);
    • pid = fork();
    • if (pid == 0){ // este es el hijo
    • dup2(pipefd[1], 1);
    • close(pipefd[1]);
    • cout<<&quot; hola papa como estas ... &quot;;
    • } else {
    • char msg[100];
    • dup2(pipefd[0], 0);
    • close(pipefd[1]);
    • cin.getline(msg,100);
    • int st;
    • waitpid(pid, &st, WIFEXITED(st));
    • cout<<&quot; msg en padre &quot;<<msg<<endl;
    • cout<<&quot; ahh!! me hijo se acuerda de mi &quot;;
    • }
    • }