HILOS
Procesos
● Un proceso es un programa en
ejecución
● Se suele decir que el programa
es la entidad pasiva y el proceso
la activa
● Los libros de texto usan los
términos proceso y tarea para
referirse normalmente a lo
mismo
● Un proceso es la unidad de
ejecución más pequeña
planificable
Ejemplo de Stack
int main(int argc, char *argv[])
{
hacer_algo(3); // 3 veces
hacer_algo-> tope =
}
0 tope =
hacer_algo->
1 tope =
hacer_algo->
void hacer_algo(int tope) {
2 tope =
hacer_algo->
if(tope > 0) {
3 = 0, argv =
main -> argc
hacer_algo(tope – 1);
[]
}
}
Estados
Conforme se ejecuta un proceso cambia su estado
● nuevo: El proceso se está creando
● en ejecución: Se están ejecutando sus instrucciones
● en espera: Está esperando que ocurra algún evento
● listo: Está esperando que le asignen la CPU
● terminado: Ha terminado su ejecución
Planificaciones
Tenemos 3 / 4 tipos de planificaciones
● Extra largo plazo: La realiza el administrador
● Largo plazo: Se controla el grado de multiprogramación
● Mediano plazo: Se controlan los procesos suspendidos
● Corto plazo: Se controla el grado de multiprocesamiento
PCB
Contiene información asociada con cada proceso
● ID
● Estado del proceso
● Contador de programa
● Registros de la CPU
● Información de planificación de CPU
● Información de gestión de memoria
● Información contable
● Información de estado de E/S
● Punteros
Colas
Cambio de contexto
● Cuando se cambia el proceso que posee la CPU, el sistema
debe salvar el estado del proceso anterior y cargar el
estado salvado del nuevo proceso
● El tiempo que dura una conmutación de contexto es un
gasto extra; el sistema no hace nada útil durante la
conmutación
● Este tiempo es Overhead
● Se tratará de minimizar
● El tiempo requerido para la conmutación depende del
soporte del procesador
● El cambio de contexto puede realizarse para cambiar de
proceso, pero también para atender una interrupción,
permitiendo que el proceso original continúe
Cambio de contexto
Hilos
● Un hilo es una unidad básica de utilización de la CPU y
consiste en un juego de registros y un espacio de pila. Es
también conocido como proceso ligero
● Comparte el código, los datos y los recursos con sus
hilos pares
● Una tarea (o proceso pesado) está formada por uno o más
hilos
● Generalmente, un hilo sólo puede pertenecer a una tarea
● Al compartir recursos, pueden comunicarse sin usar ningún
mecanismo de comunicación inter-proceso del SO
● La conmutación de contexto es más rápida
● No hay protección entre hilos. Un hilo puede escribir en la
pila de otro hilo del mismo proceso
Hilos y Procesos
un proceso un proceso
un hilo varios hilos
varios procesos varios procesos
un hilo por proceso varios hilos por proceso
Procesos con un solo hilo y
con múltiples hilos
Código Datos Archivos Código Datos Archivos
Hilo Hilos
Mono-hilo Multi-hilo
Modelos de procesos de un
solo hilo y de muchos hilos
Modelo de proceso Modelo de proceso
de un solo hilo multihilos
Hilo Hilo Hilo
Bloque de Bloque de Bloque de
Bloque Stack control control control
de control del del hilo del hilo del hilo
del proceso usuario
Bloque de Stack Stack Stack
Espacio de Stack control del del del del
direcciones del proceso usuario usuario usuario
del usuario Kernel
Espacio de Stack Stack Stack
direcciones del del del
del usuario kernel kernel kernel
Hilos
PCB
PC
TC TCB TC
B B B
Diferencias con procesos
● Permiten paralelismo dentro de un proceso o aplicación.
● Permiten la comunicación privada entre varios hilos del
mismo proceso, sin solicitar intervención del S.O.
● Mayor eficiencia en el cambio de un Hilo a otro, que de un
Proceso a otro.
● Mayor eficiencia en la creación de un Hilo que en la creación
de un Proceso Hijo.
● Un Proceso Multihilo puede recuperarse de la “muerte” de
un Hilo, pues conoce los efectos de esta, y toma su espacio
de memoria (excepto para el main).
● Cuando un Proceso “muere” todos sus Hilos también, pues
los recursos de Proceso son tomados por el Sistema
Operativo.
KLT - ULT
● Los KLTs son llamados “Hilos a nivel de Kernel”.
● El SO conoce de su existencia y controla su ejecución
● Características:
● La conmutación de contexto entre hilos es más lenta
● Si un hilo se bloquea, los hilos pares pueden continuar
● Los ULTs son llamados “Hilos a nivel de usuario”.
● Su gestión es realizada por bibliotecas en el nivel de
usuario.
● El SO no sabe nada de la existencia de estos hilos
● Características:
● Realizan la conmutación de contexto más rápidamente
● Todos los hilos de un proceso se bloquean cuando uno
de ellos realiza una operación bloqueante (ej. E/S)
Hilos a nivel usuario (un
CPU con dos núcleos)
Proceso de usuario gestiona y
Nivel usuario
planifica los múltiples hilos
Nivel kérnel
(sistema
operativo)
Planificador del SO
Hardware
CPU Core Core
Hilos a nivel kernel (con un
CPU con un solo núcleo)
Nivel usuario
Nivel kérnel
(sistema
operativo)
Planificador del SO
Hardware
CPU Core
Hilos a nivel kernel (con un
CPU con doble núcleo)
Nivel usuario
Nivel kérnel
(sistema
operativo)
Planificador del SO
Hardware
CPU Core Core
Ejemplos
Ejemplos
Ejecución típica
Espacio de
Direcciones Traza de ejecución
del Proceso 5000
Recursos 5001
5002
•I/O asignados 5003
•Archivos 5004
•Puertos 5005
5006
•Límites de 5007
Control-
Memoria PCB 5008
5009
•PID PC
5010
(identificador) 5011
•Estado 5012
5013
•Program 5014
Counter 5015
5016
Pila (v. locales)
5017
5018
5019
Datos
5020
5021
5022
5023
5024
Heap (v.
5025
5026
globales) 5027
5028
Constantes 5029
5030
Código 5031
5032
De 5033
Programa
Ejecución con hilos
Espacio de
Direcciones virtuales Trazas de ejecución
del Proceso P
5000 • H1 y H2 son
Recursos de P 5001
Hilos creados por
5002
PCB y TCB de 5003 el Proceso P.
H0 5004
TCB de H1 5005 • El Proceso P
5006
5007 define el espacio
TCB de H2 SP 5008 de direcciones.
1 5009
Pila H1 (v. locales) PC 5010 • El Proceso P es
5011
0 5012
dueño de los
5013 recursos que
SP 5014
5015
pueden usar y
Memoria de Datos
2 PC compartir H1 y
Pila H2 (v. locales)
5016
5017 1 H2.
5018
5019 • Los Hilos H1 y H2
5020
SP 5021 comparten el
0 5022 espacio de
Pila H0 (v. locales) 5023
direcciones.
de P
5024
5025
5026
PC • El Hilo H0 es el
Heap (m. 5027 2 Hilo “por
5028
dinámica)
5029 defecto” de P,
Constantes 5030 creado para la
5031
función main()
Código de 5032
5033 del Programa.
Programa de P
Dinámica de estados
• El estado del Proceso P
es la combinación de
los estados de sus
Hilos.
• Cuando cualquiera de
los Hilos está en estado
“Ejecutando”, el
estado de P será H1 H2
“Ejecutando”.
• Si ningún Hilo está en
“Ejecutando”, si
alguno está en “Listo”,
el estado de P será
“Listo”. Proceso P
• El estado de P es
“Bloqueado” sólo si
todos sus Hilos están
Estado
enEjecutando estado
Estado
“Bloqueado”.
Listo
Estado
Bloqueado
Procesos Hijos
● Un Proceso puede crear otro Proceso,
iniciando una tarea mientras termina
otra. P1
● En la figura, P2 y P3 son Hijos de P1, y
P4 es hijo de P2.
● Jerarquía entre Procesos: P2 P3
● Padre e Hijo se pueden ejecutar
concurrentemente (quizás en paralelo).
● El Padre hace su trabajo y debe esperar
a que el Hijo termine para terminar.
P4
● Padre e Hijo pueden compartir todos
los recursos, una parte de ellos, o
ninguno.
● La estructura de Memoria de un
Proceso Hijo es un duplicado de la
estructura del Padre (espacio de
direcciones).
Creación de hijos vs hilos
P1 crea
PCB P1 P2 PCB P1
H1 crea
TCB H1.P1 H2
PCB P2
TCB H2.P1
Imagen P1 Imagen P1
Imagen P2 H1 y H2 son
Hilos de P1 Y
P2 es comparten los
Hijo de recursos. H2 es
P1 Hijo de H1
Creación de procesos
Imagen de Proceso Imagen de Proceso
padre
#include <stdio.h> hijo
#include <stdio.h>
#include <unistd.h> #include <unistd.h>
P int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
int pid; int pid;
pid = fork(); pid = fork();
if (pid < 0) { if (pid < 0) {
fprintf(stderr, fprintf(stderr, “Falló");
“Falló"); exit(-1);
exit(-1); } else if (pid == 0) {
} else if (pid == /* Inicio de código de
0) { Proceso Hijo */
/* Inicio de H
execlp("/bin/
código de Proceso Hijo */ ls“,"ls”,NULL);
execlp("/bin/ …
ls“,"ls”,NULL); /* Fin de código de
… Proceso Hijo */
/* Fin de } else {
código de Proceso Hijo */ /* Inicio de código de
} else { Proceso Padre */
/* Inicio de …
código de Proceso Padre */ /* Esperar término del
… Hijo */
/* Esperar wait(NULL);
término del Hijo */ printf("Child Complete");
wait(NULL); exit(0);
printf("Child …
Complete");
/* Fin de código de
exit(0); Proceso Padre */
… }
/* Fin de }
Creación de hilos
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
void *print_message_function( void *ptr );
main() {
H pthread_t hilo1, hilo2;
0 char *message1 = “Hilo 1";
char *message2 = “HIlo 2";
int iret1, iret2;
iret1 = pthread_create( &hilo1, NULL, print_message_function, (void*)
message1);
iret2 = pthread_create( &hilo2, NULL, print_message_function, (void*)
message2);
pthread_join( hilo1, NULL);
pthread_join( hilo2, NULL);
printf(“El Hilo 1 devuelve: %d\n",iret1);
printf(“El Hilo 2 devuelve: %d\n",iret2);
exit(0);
}
void *print_message_function( void *ptr ) {
char *message;
H message = (char *) ptr;
printf("%s \n", message);
1
2 }
Terminación de procesos
● La última operación de un proceso es una llamada
al SO indicando que lo elimine (exit)
● Se envía al padre información de salida (via
wait)
● Los recursos usados por el proceso son liberados
● Un proceso padre puede terminar la ejecución de
sus hijos (abort)
● El hijo se ha excedido en el uso de recursos
asignados
● La tarea que realiza el hijo no es ya necesaria
● El padre va a terminar
● Algunos SOs no permiten que un hijo siga si
su padre termina. Todos los hijos son
terminados – terminación en cascada
● Otros transfieren el hijo al padre (del padre)
¿Preguntas?
