S O

Tema 2. Procesos e hilos

II

Índice
■Concepto de proceso
■Información del proceso
■Estados del proceso
■Formación de un proceso
■Concepto de hilo de ejecución
■Procesos en Minix
■Procesos en Linux
■Procesos en Windows NT/2000
■Planificación de procesos e hilos
■Servicios POSIX para gestión de procesos e hilos

Sistemas Operativos II (II-UJI) Procesos e hilos

1
 Índice
■Procesos en Minix
✓ Estados de un proceso
✓ Implementación del descriptor de proceso
■Procesos en Linux
✓ Estados de un proceso
✓ Implementación del descriptor de proceso
✓ Implementación de la tabla de procesos
✓ Implementación de la lista de procesos preparados
■ Procesos en Windows NT/2000
✓ Objetos tipo proceso e hilo
✓ Estados de un hilo
✓ Implementación del procesos e hilos
Índice
■Planificación de procesos e hilos
✓ Planificación en Minix
✓ Planificación en Linux
✓ Planificación en Windows NT/2000
Bibliografía
■J. Carretero et al. Sistemas Operativos: Una Visión Aplicada.
McGraw- Hill. 2001. Capítulo 3
■W. Stallings. Sistemas Operativos. Prenctice-Hall. 2001. Capítulos 3,
4, 9 y 10
■A.S. Tanenbaum, A.S. Woodnull. Operating Systems. Design
and Implementation. Prentice-Hall International, 2a. edición.
1996.
■H. Custer. Inside Windows NT. Microsoft Press. 1993.
 Índice
“ ■ Concepto de proceso
■Información del proceso
■Estados del proceso
■Formación de un proceso
■Concepto de hilo de ejecución
■Procesos en Minix
■Procesos en Linux
■Procesos en Windows NT/2000
■Planificación de procesos e hilos
■Servicios POSIX para gestión de procesos e hilos
 S O
Concepto de proceso II

■¿Qué es un proceso?
◆ Instancia de un programa en ejecución, requiriendo para ello
unos recursos
Proceso

Programa Pila
Otros recursos:
-Ficheros abierto
-Dispositivos E/S, etc.
Recursos:
-Procesador
-Zonas de memoria Datos
-Ficheros PC
Código
-Dispositivos, etc.

Programa: estructura pasiva Proceso: estructura activa

■Jerarquía de procesos:
◆ Algunos SO, como Unix, mantienen una estructura jerárquica
entre procesos
init

Inicio Inici Inicio Inicio Dem. Impr. Dem. Com..

o
Shell Shell Proceso init:
Proceso A ● PID = 1
Editor
● Ancestro de todos los procesos
Proceso B Proceso D Proceso C

Proceso E Proceso F

◆ Otros, como Windows NT/2000 (en adelante WNT/2K), no la mantienen

■El proceso nulo (o la tarea ociosa):
◆ ¿Qué ocurre cuando el procesador está ocioso?
●Se ejecuta el proceso nulo

◆ ¿Qué hace el proceso nulo?

●Ejecuta un bucle infinito que no realiza ninguna operación útil
●En sistemas Unix suele tener PID=0

◆ Objetivo:
●Entretener al procesador cuando no hay ninguna otra tarea
■Entorno del proceso:
◆ Tabla NOMBRE-VALOR que se pasa al proceso en su creación
◆ Se incluye en la pila
◆ Se establece:
●Por defecto
●Mediante mandatos del shell (export)
●Mediante API del SO (putenv, getenv )
◆ Ejemplo de entorno de un proceso en Unix:
●$env
LOGNAME=castano
SHELL=/bin/bash
TERM=vt100
HOME=/users/icc/castano
PATH=/usr/local/bin:/bin:/usr/bin:/users/castano/bin
...
■Grupos de procesos:
◆ Los procesos forman grupos de procesos con alguna característica
común
●Conjunto de procesos creados por el mismo padre
●Conjunto de procesos creados a partir de un shell
●Conjunto de procesos dependientes de un terminal

◆ Se pueden realizar ciertas operaciones sobre un grupo de procesos

●Matar todos los procesos de un grupo de procesos
●Envío de señales a todos los procesos de un grupo de procesos
 ■Servicios POSIX
Tema 2. Procesos e hilos para gestión de
procesos e hilos
S O II
II

Índice
■Concepto de proceso
“ ■ Información del proceso
■Estados del proceso
■Formación de un proceso
■Concepto de hilo de ejecución
■Procesos en Minix
■Procesos en Linux
■Procesos en Windows NT/2000
■Planificación de procesos e hilos

Sistemas Operativos II (II-UJI) Procesos e hilos

11
 S O
Información del proceso II

■Estado del procesador:

◆ Contenido de los registros del modelo de programación

■Imagen de memoria:
◆ Contenido de los segmentos de memoria en los que reside el código
y los datos del proceso

■Bloque de control de proceso (BCP)

 Registro
s
especial Mapa de
es
memoria del
Proceso A
Tablas del sistema operativo
Mapa de
memoria del Tabla de
Registro Proceso B procesos
s BCP Proceso A BCP Proceso B BCP Proceso C
generale Mapa de
- Estado - Estado - Estado
s memoria del
Proceso C (registros) (registros) (registros)
- Identificación - Identificación - Identificación
Tablas SO - Control - Control - Control
- Tabla de memoria
PC - Tabla de E/S
Mapa - Tabla de ficheros
SP de
Estado
 S O
Estado del procesador II
II

■Formado por el contenido de todos los registros del procesador:

◆ Registros generales
◆ Contador de programa
◆ Puntero de pila
◆ Registro de estado
◆ Registros especiales

■Cuando un proceso está ejecutando su estado del procesador reside en

los registros del computador

■Cuando un proceso no se está ejecutando su estado del procesador

reside en el BCP
Preparación del código de un proceso II

Problema

Editor

Módulo Módulo
fuente A fuente B

Compilador
o
ensamblad
or

Módulo Módulo Otros

objeto A objeto B objetos

Montador

Objeto Bibliotecas
ejecutable del sistema

Cargad
or
Ejecutable
en
memori
a
 S O
Imagen de memoria II

■Formada por los espacios de memoria que un proceso está autorizado

a utilizar
■La memoria del proceso la asigna el gestor de memoria del SO

■Si un proceso genera una dirección que esta fuera del espacio de
direcciones el HW genera una interrupción HW interna

■La imagen de memoria, dependiendo del computador, puede estar referida

a memoria virtual o memoria física
 ■Imagen de memoria de un proceso en un sistema con memoria virtual:

Registro identificador de estado de

direccionamiento
RIED
Memor Memoria
ia principal
virtua
Código
l

Tamaño
Dat
os Disco

Tabla de
Pila páginas

Una tabla de páginas por

proceso
 S O
Información del BCP II

■Información de identificación:
◆ PID del proceso, PID del padre
◆ ID de usuario real (uid real)
◆ ID de grupo real (gid real)
◆ ID de usuario efectivo (uid efectivo)
◆ ID de grupo efectivo (gid efectivo)

■Estado del procesador

■Información de control del proceso: Tabla de ficheros

abiertos por el proceso
◆ Información de planificación y estado
◆ Descripción de los segmentos de memoria del proceso
◆ Recursos asignados (ficheros abiertos, ...)
◆ Comunicación entre procesos (señales, ...)
◆ Punteros para estructurar los procesos en listas o colas
■¿Qué información del proceso se saca fuera del BCP?
◆ La que tiene tamaño variable
●Ejemplo: Tabla de páginas
●Razones de eficiencia
●La tabla de procesos se construye como una estructura
estática, formada por un número de BCP del mismo tamaño

◆ La que se comparte:
●El BCP es de acceso restringido al proceso que lo ocupa
●Ejemplo: Punteros de posición de ficheros abiertos por el proceso
■Tabla de páginas:
◆ Describe la imagen de memoria del proceso
◆ Tamaño variable
◆ El BCP contiene el puntero a la tabla de páginas
◆ La compartición de memoria requiere que sea externa al BCP

■Punteros de posición de los ficheros:

◆ Si se asocian a la tabla de ficheros abiertos por los procesos (en el
BCP) no se pueden compartir
◆ Si se asocian al i-nod se comparten siempre
◆ Se ponen en una estructura común a los procesos y se asigna uno
nuevo en cada servicio open
 S O
Compartir información II
II

BCP 4

BCP 7 BCP 23
Tabla Tabla Tabla de
de de ficheros
ficheros ficheros
0 23 0 23 0 54
f 1 4563 fd 1 4563 fd 1 63
d 3
2 56 2 56 2 53
68
34 34 3 33

ID P
FF P ● El proceso con BCP7 es hijo del proceso con BCP4
1 0
24456
2 234
● Los procesos con BCP7 y BCP4
34512 5 comparten punteros a los mismos ficheros
● El proceso con BCP23 abre uno de los
Tabla de ficheros del sistema ficheros compartido por los procesos con
BCP7 y BCP4
 S O
IDFF = Identificativo de fichero
PP = Posición puntero al II
fichero
 S O
Tablas del SO II

■Tabla de procesos: Tabla con los BCP de los procesos del sistema

■Tabla de memoria: Información sobre el uso de la memoria

■ Tabla de E/S: Información asociada a los periféricos y a las operaciones

de E/S

■Tabla de ficheros: Información sobre los ficheros abiertos en el sistema

■Implementación de una cola de procesos listos:

Cola de procesos Inicio

listos Fin

Proceso 7 BCP 1
Proceso 5 BCP 2
Proceso 3 BCP 3

Proceso 9 BCP 4

Tabla de procesos
 S O
Usuarios y grupos reales y efectivos II

■Usuarios reales y efectivos:

◆ UID (“real user identifier”): Identificativo real del usuario
Usuario responsable del proceso en ejecución

◆ EUID (“effective user id.”): Identificativo efectivo del usuario

Se usa para:
 Acceder a ficheros de otros usuarios
 Enviar señales a procesos
 Ejecutar programas “setuid”
■Grupos reales y efectivos:
◆ GID (“real group identifier”):

◆ EGID (“effective group identifier”)

■Programas “SETUID”:
◆ Cuando un proceso ejecuta un programa “setuid” el núcleo asigna al EUID
del proceso el identificativo del propietario de dicho programa y al EGID
del proceso el identificativo del grupo del propietario de dicho programa
◆ Ejemplos de programas “setuid”: login, mount, passwd, mkdir, etc.
◆ Cambio del bit “setuid” para el usuario y del bit “setgid” para el grupo:

chmod 4511 (ó chmod u+s)

-r-x-—x-—x -r-s--x-—x
Bit “setuid”
chmod 4411 (ó chmod u+s)
-r---—x-—x -r-S--x-—x
Bit “setgid”
chmod 2510 (ó chmod g+s)
-r-x—-x-----------------------------r-x-—s—--
 ■Servicios POSIX
Tema 2. Procesos e hilos para gestión de
procesos e hilos
S O II
II

Índice
■Concepto de proceso
■Información del proceso
“ ■ Estados del proceso
■Formación de un proceso
■Concepto de hilo de ejecución
■Procesos en Minix
■Procesos en Linux
■Procesos en Windows NT/2000
■Planificación de procesos e hilos

Sistemas Operativos II (II-UJI) Procesos e hilos

26
 S O
Estados de un proceso II

■Cuando un proceso se ejecuta pasa por distintintos estados

■Diagrama de transición entre estados:

Ejecución Exit

Fin E/S o llegada

Listo evento Bloqueado
■Estados suspendidos:

Exit
Ejecución

Memoria
Listo
Recuperado del disco
Fin E/S o llegada evento Bloqueado

Expulsado al disco

Expulsado al disco
Entra al
sistema

Zona de intercambio
Procesos por Listo y Fin E/S Bloqueado y
suspendido suspendido
lotes en
espera
 ■Servicios POSIX
Tema 2. Procesos e hilos para gestión de
procesos e hilos
S O II
II

Índice
■Concepto de proceso
■Información del proceso
■Estados del proceso
“ ■ Formación de un proceso
■Concepto de hilo de ejecución
■Procesos en Minix
■Procesos en Linux
■Procesos en Windows NT/2000
■Planificación de procesos e hilos

Sistemas Operativos II (II-UJI) Procesos e hilos

29
 S O II
Formación de un proceso II

Mapa de
memoria Tabla de procesos

Objeto Ca rg a d or
Imagen BCP
ejecutable
del proceso
Biblioteca
sistema

Sistemas Operativos II (II-UJI) Procesos e hilos

30
 ■Servicios POSIX
Tema 2. Procesos e hilos para gestión de
procesos e hilos
S O II
II

Índice
■Concepto de proceso
■Información del proceso
■Estados del proceso
■Formación de un proceso
“ ■ Concepto de hilo de ejecución
■Procesos en Minix
■Procesos en Linux
■Procesos en Windows NT/2000
■Planificación de procesos e hilos

Sistemas Operativos II (II-UJI) Procesos e hilos

31
 S O
Concepto de hilo de ejecución II

■Características básicas del modelo tradicional de proceso (pesado):

◆ Ejecución secuencial.
◆ Ejecución independiente.

■Planteamiento:
◆ Varios procesos pueden cooperar para resolver una misma tarea del SO
‹ Ejecución concurrente entre procesos ‹ Comunicación
entre procesos, por ejemplo, a través de memoria.
◆ Un programa podría incluir varias actividades concurrentes ‹
Ejecución concurrente dentro de un proceso.
■¿Qué es un hilo de ejecución?
◆ También llamado hebra, proceso ligero, flujo, subproceso o “thread”.
◆ Programa en ejecución que comparte la imagen de memoria y otros
recursos del proceso con otros hilos.
◆ Desde el punto de vista de programación: Función cuya ejecución
se puede lanzar en paralelo con otras.
◆ Un proceso puede contener uno o más hilos.
■¿Qué es un hilo de ejecución (cont.)?

Pila 1
Otros recursos:
Hilo 1 -Ficheros abierto
-Dispositivos E/S, etc.
Pila2
Proceso

Hilo 2
PC2
Datos
PC1
Código

Hilo: unidad de planificación Proceso: unidad de asignación de recursos

■Descriptor de un proceso y de un hilo:

Hilo 2

Hilo 1 (principal) ...

Estado, tiempo de CPU,
...
Hilos registros de CPU, pila, etc.
Hilo
j
Espacio de direcciones
Zonas de memoria ...

Gestión de E/S Ficheros abiertos, dispositivos abiertos, etc.

Otros datos
■Descriptor de un proceso y de un hilo:
◆ Todos los hilos de un proceso comparten el mismo entorno de
ejecución (variables globales, espacio de direcciones, ficheros abiertos,
etc.).
◆ Cada hilo tiene su propio juego de registros de CPU, pila,
variables locales, etc.
◆ No existe protección entre hilos: un error en un hilo puede estropear
la pila de otro.
◆ Para ordenar la forma en la que los hilos acceden a datos comunes
hay que emplear mecanismos de sincronización.
 S O
Estados de un hilo y de un proceso II
II

■Estado de un proceso con hilos:

◆ Combinación de los estados de sus hilos:
●Si hay un hilo en ejecución ‹ Proceso en ejecución
●Si no hay hilos en ejecución pero sí preparados ‹ Proceso preparado
●Si todos sus hilos bloqueados ‹ Proceso bloqueado

Bloqueado por comunicación

Proceso Bloqueado por acceso a disco
Activo

Hilo
 Paralelización usando hilos II

■Los hilos permiten paralelizar la ejecución de una aplicación

■Mientras un hilo está bloqueado, otro podría ejecutarse
◆ Uso de llamadas al sistema bloqueantes por hilo

Procedimiento 1 Procedimiento 2
P Ejecución
Espera P F
Espera serie
en E/S
F
en E/S

Procedimiento 1

P F
Espera
en E/S
Ejecución
Procedimiento 2 Espera en E/S

P
 paralela
F Procesamiento
 S O
Servidor con múltiples hilos II

Hilo distribuidor Proceso

Hilo trabajador

Peticiones

■ Hilos trabajadores:
◆ Pueden crearse a medida que se necesitan y destruirse al finalizar
la tarea encomendada
◆ Pueden existir siempre y quedar libres al finalizar la tarea encomendada
●Más eficiente (evita el trabajo de crear y destruir hilos)
■ Ejemplo: Servidor secuencial de ficheros

Algoritmo Caché para bloques

accedidos recientemente
Mientras no haya que terminar
{ Esperar a que llegue una
petición
Comprobar que la petición es
correcta Si (los datos no están en la
caché) {
Realizar operación de E/S bloqueante sobre disco
}
Enviar resultado
}
●Sencillo
●Prestaciones pobres: permanece bloqueado
■ Ejemplo (cont.): Servidor de ficheros con múltiples hilos

Hilo Hilo trabajador

distribuidor
Algoritmo Algoritmo
1 2
Mientras no haya que terminar Mientras no haya que terminar
{ Esperar a que llegue una { Esperar trabajo
petición Esperar trabajador libre Comprobar que la petición es
} correcta Si (los datos no están en la
Enviar resultado caché) {
} Realizar operación de E/S
bloqueante sobre disco
}
Enviar resultado
Avisar que está libre
}
●Mayor complejidad
●Buenas prestaciones
 S O
Concepto de multihilo II
II

■ Capacidad de un SO para mantener varios hilos de ejecución dentro de un

mismo proceso.
Proceso
Mono
Proce Hilo
Sadproce
o
res
hilo/pr
oceso U

MultiMS-
ProcDOS
e
sado
res

Múltiple
g
 S O
U
n n Ej: Java
o p II
s r
o
U c
e
N s
o
I M
X ú Múltiples
l procesos
t Múltiples
i hilos/proceso
Téc
p
nica l Ej: Windows 2000,
mon e Solaris, OS/2
ohil s
o
h
i Técnica multihilo
l
o
s
/
p
r
o
c
e
s
o
 Implementación de hilos II

■ Dos categorías:
◆ Hilos a nivel de usuario
◆ Hilos a nivel de núcleo
 S O
Hilos a nivel de usuario II

■ Gestión de hilos realizada por la aplicación a nivel de usuario mediante una

biblioteca de hilos.
■ El núcleo no es consciente de la existencia de hilos.
■ Es posible programar cualquier aplicación como multihilo.

Hilo a nivel de usuario

P Proceso
Biblioteca de hilos
Modo usuario
Modo
supervisor

P
■ Ventajas frente a hilos a nivel de núcleo:
◆ No necesario acceder al núcleo para intercambio de hilos.
◆ Algoritmos de planificación ad-hoc para cada aplicación.
◆ Pueden ejecutarse en cualquier SO.

■ Desventajas frente a hilos a nivel de núcleo:

◆ Una llamada al sistema realizada por un hilo bloquea a todos los
hilos del proceso.
◆ Una aplicación multihilo no puede aprovechar las ventajas
del multiprocesamiento.

■ Ejemplo:
◆ Pthreads de POSIX.
 S O
Hilos a nivel de núcleo II

■ Gestión de hilos realizada por el núcleo.

■ Es posible programar cualquier aplicación como multihilo.

Hilo a nivel de usuario

Hilo a nivel de núcleo

Modo usuario
Modo supervisor P Proceso

P
■ Ventajas frente a hilos a nivel de usuario:
◆ El bloqueo de un hilo no supone (necesariamente) bloquear todo
el proceso.
◆ Planificación de múltiples hilos de un proceso en
múltiples procesadores.
◆ Las funciones del núcleo pueden ser multihilo.

■ Desventajas frente a hilos a nivel de usuario:

◆ El intercambio de hilos se realiza accediendo al núcleo.

■ Ejemplos:
◆ Linux, Windows 2000, OS/2.
 S O
Aproximaciones combinadas II

■ Ejemplo: Solaris
◆ Creación, sincronización y planificación de hilos de una
aplicación en modo usuario.
◆ Planificación de múltiples hilos de un proceso en múltiples
procesadores.
◆ El bloqueo de un hilo no supone (necesariamente) bloquear
todo el proceso.
■ Ejemplo: Solaris (cont.)

Hilo a nivel de usuario

Hilo a nivel de núcleo

Biblioteca de hilos
Modo usuario
Modo supervisor P Proceso

P P
 S O
Modelos multihilo II
II

■ Relación de:
HNU:HNN Descripción Ejemplos
◆ Muchos a uno.
M:1 Pthreads POSIX
◆ Uno a uno.
◆ Muchos a muchos.

1:1 Windows 2000, OS/2

M:N Solaris
Hilo a nivel de usuario (HNU)

Hilo a nivel de núcleo (HNN)

 Concepto de hilo de ejecución II

■ Ventajas de utilizar múltiples hilos:

◆ La ejecución concurrente de hilos de un mismo proceso puede
mejorar la eficiencia del sistema.
●Paralelismo dentro del proceso (en multiprocesadores).
●Las operaciones bloqueantes no paralizan al proceso (completo).
◆ Mayor eficiencia que con múltiples procesos en:
●Creación/eliminación de unidades de planificación.
●Cambio de contexto.
◆ Una buena solución para sistemas cliente/servidor.
◆ Facilidad de implementación.
 Tema 2. Procesos e hilos
S O II
II

Índice
■Concepto de proceso
■Información del proceso
■Estados del proceso
■Formación de un proceso
■Concepto de hilo de ejecución
“ ■ Procesos en Minix
✓ Estados de un proceso
✓ Implementación del descriptor de proceso

Sistemas Operativos II (II-UJI) Procesos e hilos

52
 S O
Procesos en Minix II
■ Diagrama de transición entre estados:

En ejecución
unready
pick_pro
c
sched

Bloqueado
Listo ready

◆ ready: Pone el proceso en alguna de las colas de

procesos listos del planificador  Activa el proceso
◆ unready: Elimina el proceso de las colas de procesos listos 
Suspende el proceso
◆ pick_proc: Selecciona el proceso listo a ser ejecutado por la CPU

Planificador
◆ sched: Pone al final de la cola el proceso de usuario en
 S O
Procesos en Minix II
ejecución pues éste ha agotado su quantum de CPU
■ Descriptor de un proceso:

EXTER struct proc{

N p_reg[NR_REGS]; /* process’ registers */
in
t
in *p_sp; /* stack pointer */
t
struct pc_psw p_pcpsw; /* pc and psw as pushed by
interrupt*/ struct mem_map p_map[NR_SEGS];/* memory map */
int *p_splimit; /* lowest legal stack value */

int p_pid; /* process id passed in from MM*/

int p_flags; / P_SLOT_FREE, SENDING, RECEIVING, */
* or 0 if the process is runnable */
/
*
real_time user_time; /* user time in ticks */
real_time sys_time; /* sys time in ticks */
real_time child_utime; /* cumulative user time of children */
real_time child_stime; /* cumulative sys time of children */
real_time p_alarm; /* time of next alarm in ticks, or 0
*/
■ Descriptor de un proceso (cont.):

struct proc *p_callerq; / head of list of procs wishing to send */

*
struct proc / link to next proc wishing to send */
*p_sendlink; *
message *p_messbuf; / pointer to message buffer */
*
int p_getfrom; / from whom does process want to receive?
* */

stuct proc / pointer to next ready process */

*p_nextready; *
int p_pending; / bit map for pending signals */
*
} proc[NR_TASKS+NR_PROCS];
 o
Tema 2. Procesos e hilos s
e
S O II n
II
M
i
n
Índice i
■ Concepto de proceso x

■ Información del proceso “

■
■ Estados del proceso
P
■ Formación de un proceso
r
■ Concepto de hilo de ejecución
o
P
r c
o e
c
e s
s o

Sistemas Operativos II (II-UJI) Procesos e hilos

56
s

e
n

L
i
n
u
x
✓ Estados de un proceso
✓ Implementación del descriptor de proceso
✓ Implementación de la tabla de procesos
✓ Implementación de la lista de procesos
preparados

Sistemas Operativos II (II-UJI) Procesos e hilos

57
 S O
Procesos en Linux II

■Diagrama de transición entre estado típico.

■Bloqueo de un proceso:
◆ Espera a que ocurra un cierto evento
◆ Proceso bloqueado e interrumplible:
●Puede ser interrumpido por señales
●Puede desbloquearle:
 Una interrupción HW
 Liberación de un recurso por el que esperaba
 Una señal

◆ Proceso bloqueado e ininterrumplible:

●No acepta señales
●Puede desbloquearle:
 Una interrupción HW
 Liberación de un recurso por el que esperaba
■ Descriptor de un proceso:
◆ Estructura task_struct del fichero include/linux/sched.h

■ Estado del proceso:

volatile long state;
#define TASK_RUNNING 0 /*
#define TASK_INTERRUPTIBLE 1 /*
#define TASK_UNINTERRUPTIBLE 2 /*
#define TASK_ZOMBIE 3 /*
#define TASK_STOPPED 4 /*
Proceso listo o en ejecución */
Proceso bloqueado interrumpible */
Proceso bloquea ininterrumpible */
Proceso finalizado */
Proceso parado tras llegar una
señal SIGSTOP*/

unsigned long flags; /* Combinación de las d estad *

banderas e o /
#define PF_STARTING 0x00000002 /* Recién *
creado /
#define PF_EXITING 0x00000004 /* Finalizando *
/
Variable current: Puntero a la estructura task_struct del proceso en ejecución
■ Identificativos del proceso:

pid_ pid; / Identificativo del proceso */

t *
pid_ pgrp; / Identificativo del grupo del proceso*/
t *
pid_ session; / Número de sesión del proceso */
t *
uid_ uid,euid; / Identificativo real y efectivo del usuario */
t *
gid_ gid,egid; / Identificativo real y efectivo del grupo */
t *
gid_ groups[NGROUPS] / Lista grupos a los que pertenece el proceso
t ; * */
■ Planificación del proceso:

unsigned long policy; / Tres posibles políticas de planificación */

*
#define SCHED_FIFO 1
#define SCHED_RR 2
#define 0
SCHED_OTHER
long counter; / Procesos SCHED_OTHER: Tiempo de CPU
* por consumir */
/ Procesos RR: Valor actual del quantum de
* CPU (prioridad dinámica) */
long priority; / Procesos RR: Valor inicial del quantum de
* CPU
(prioridad estática) */

Los tiempos de CPU se miden en tics de reloj

■ Jerarquía del proceso:
struc task_struc *p_opptr /* Original parent
t t ; */
struc task_struc *p_pptr; /* Parent */
t t
struc task_struc *p_cptr; /* Youngest child */
t t
struc task_struc *p_ysptr /* Younger sibling
t t ; */
struc task_struc *p_osptr /* Older sibling */
t t ;

padre

p_pptr

p_osptr p_osptr
hijo más hijo más
joven hijo
p_ysptr viejo
p_ysptr
■ Señales del proceso:

struc sigset_ signal; /* Map d bit d señale recibidas

t t a e s e s
*/
struc sigset_ blocked; /* Map d bit d señale bloqueadas
t t a e s e s */
struc sigset_ sigpending; /* Map d bit d señale no
t t a e s e s bloqueadas
y pendientes */
struct signal_struct *sig; /* Manejadores de señales */
struct signal_struct {
atomic_t count;
struct sigaction action[NSIG];/* Función que modifica el tratamiento
por defecto de la señal */
};
int exit_signal; /* Número de señal que mató al proceso */
struct wait_queue *wait_chldexit; /* Lista de espera de finalización de
hijos */
■ Monitorización del proceso:

lon per_cpu_utime[NR_CPU]; /* Tiemp del en modo usuario */

g o proceso
lon per_cpu_stime [NR_CPU]; /* Tiemp del en modo supervisor */
g o proceso
lon start_time; /* Tiemp de del proceso */
g o creación

/* Tiempos sobre temporizadores y alarmas

*/
unsigne lon it_real_value; /* Tiempo real */
d g
unsigne lon it_prof_value, /* Tiempo en ejecución o estado listo */
d g
unsigne lon it_virt_value; /* Tiempo en ejecución sin contar la
d g ejecución de llamadas al sistema */
struct timer_list real_timer; /* Lista de alarmas */
¿Temporizador vs. Alarma?
■ Segmentos de memoria del proceso:
struct mm_struct *mm;

struct mm_struct {
...
struc vm_area_struc *mmap;
t t
struc vm_area_struc *mmap_avl;
t t
struc vm_area_struc *mmap_cache
t t ;

unsigne lon start_code, end_code; /* Dirección de inicio y fin

d g del segmento de código */
unsigne lon start_data, end_data; /* Dirección de inicio y fin
d g del segmento de datos */
unsigne lon start_stack; /* Dirección del tope del
d g segmento de pila de usuario
*/
...
};
■ Sistema de ficheros del proceso:
struct fs_struct *fs; /* Información del sistema de ficheros */
struct files_struct *files; /* Información de ficheros abiertos por el proceso */

struct fs_struct {
atomic_t count; /* Número de procesos que comparten esta estructura
*/ int umask; /* Máscara de creación de ficheros */
struct dentry * root; /* Directorio raíz del proceso
*/ struct dentry * pwd; /* Directorio de
trabajo */
};

struct files_struct {
tomic_t count; /* Num. procs que comparten estos ficheros abiertos
*/ fd_set * close_on_exec; /* Ficheros a cerrar ante una llamada exec */
fd_set * open_fds; /* Máscara bits de los descriptores de fichs usados
*/ struct file * fd_array[NR_OPEN_DEFAULT];
/* Tabla de ficheros abiertos por el proceso*/
};
■ Sistema de ficheros del proceso (cont.):

0 Tabla de inodos
1 Tabla de ficheros
2 del sistema
3
4
1 /etc/passwd
5
6 2 /usr/castano
Tabla de ficheros
del proceso
..
.
1 READ
..
.
1 WRITE
1 READ
..
.
..
.
 Incluye el proceso en ejecución
■ Lista de procesos preparados:
◆ Lista circular doblemente enlazada que comienza y finaliza con el proceso
init_task (PID=0)
struct task_struct *next_run; /* Siguiente proceso de esta lista
*/ struct task_struct *prev_run; /* Anterior proceso de esta lista
*/

extern struct task_struct init_task; /* Cabeza y cola de la lista */

int nr_running; /* Num. total de procesos listos */

struct task_struct *current; /* Proceso en ejecución */

procesoinit_task proceso A proceso B

next_run

prev_run
■ Lista de procesos del sistema:
◆ Lista circular doblemente enlazada que comienza y finaliza con el proceso
init_task
struct task_struct *next_task; /* Siguiente proceso de esta lista
*/ struct task_struct *prev_task; /* Anterior proceso de esta lista
*/

extern struct task_struct init_task; /* Cabeza y cola de la lista */

procesoinit_task proceso A proceso B

next_task

prev_task
■ Tabla de procesos:

◆ Vector task del fichero kernel/sched.c

struct task_struct * task[NR_TASKS] = {&init_task, };

struct task_struct init_task;

■ Operaciones habituales sobre (todos los procesos de) la lista de procesos del
sistema:

◆ Vector task del fichero kernel/sched.c

#define for_each_task(p) \
for (p = &init_task ; (p = p->next_task) != &init_task ; )
 Tema 2. Procesos e hilos
S O II
II

Índice
■Concepto de proceso
■Información del proceso
■Estados del proceso
■Formación de un proceso
■Concepto de hilo de ejecución
■Procesos en Minix
■Procesos en Linux
“ ■ Procesos en Windows NT/2000
✓ Objetos tipo proceso e hilo
✓ Estados de un hilo
✓ Implementación del procesos e hilos
Sistemas Operativos II (II-UJI) Procesos e hilos
70
 S O
Procesos en Windows NT/2000 II

■ Características de un proceso de Windows NT/2000:

◆ Los procesos NT se implementan como objetos y son
accedidos mediante servicios de objetos
◆ Un proceso NT tiene asociados varios hilos que se ejecutan en
su espacio de direccionamiento
◆ El gestor de procesos NT no mantiene ninguna relación entre
los procesos que crea
 Objeto tipo proceso:

Tipo del
■

objeto
PROCESO

Identificativo de proceso
Objeto de acceso

del objeto
Atributos
Prioridad base
Afinidad del procesador
Tiempo de ejecución
Puertos de
comunicación Estado de
finalización etc.

Crear proceso
del objeto

Abrir proceso
Servicios

Pedir información del proceso

Añadir información del proceso
Finalizar proceso
Asignar/liberar memoria virtual
Leer/escribir memoria virtual
etc.
■ Objeto tipo proceso (cont.):
Atributo Descripción
ID proceso Valor único que identifica al proceso
Acceso Objeto con información de seguridad sobre
el usuario que generó el objeto
Prioridad base Prioridad base de sus hilos
Afinidad del procesador Procesadores en los que se pueden ejecutar sus
hilos
Límites de cuotas Cantidad máxima de memoria paginada y no
paginada, de tiempo de ejecución, etc.
Tiempo de ejecución Tiempo total de ejecución de todos sus hilos
Puertos comunicación Canal de comunicación al que enviar un mensaje
si
un hilo genera una excepción
Estado de finalización Motivo de la finalización del proceso
 Objeto tipo hilo:

Tipo del
■

objeto
HILO
Identificativo de hilo
Contexto
Prioridad base

del objeto
Atributos
Prioridad dinámica
Afinidad del
procesador Tiempo de
ejecución Puerto de
terminación Estado de
finalización etc.

Crear
del objeto

hilo Abrir
Servicios

hilo
Pedir información del hilo
Añadir información del hilo
Finalizar hilo
Suspender/continuar hilo
Guardar/cargar contexto
etc.
■ Objeto tipo hilo (cont.):
Atributo Descripción
ID hilo Valor único que identifica al hilo
Contexto Valores de los registros y de otros datos que
definen su estado de ejecución
Prioridad dinámica Prioridad de ejecución en ese instante
Prioridad base Límite inferior de la prioridad dinámica
Afinidad del procesador Procesadores en los que se puede
ejecutar
Tiempo de ejecución Tiempo de ejecución transcurrido en modo usuario y
en modo supervisor
Puerto de terminación Canal de comunicación al que enviar un mensaje
cuando finaliza
Estado de finalización Motivo de la finalización del subproceso
■ Diagrama de transición entre estados (de un hilo):

Inicializado
Reinicializar

Finalizado Listo

Finalización
Bloqueado
Esperar evento

Ejecución
Alerta

A CPU
■ Algunos estados de un hilo:
◆ Alerta: Seleccionado como el siguiente hilo a ser
ejecutado en un procesador dado
Operación (planificación) previa a la invocación de un cambio
de contexto
◆ Bloqueado:Espera a que un objeto de sincronización pase a
una situación de marcado ("signaled") que indique la llegada
del evento de espera
■ Implementación de procesos e hilos en Windows NT/2000:

Objeto
de aceeso

Descripción del espacio virtual de direccionamiento

Objeto ...
proceso

Tabla de objetos

Subproceso x

Fichero y

. Sección z
.
.
 ón en
Tema 2. Procesos e hilos Windo
ws
S O II NT/20
00
II

Índice ■Procesos en Linux

■Concepto de ■Procesos en
proceso Windows NT/2000

■Información del “ ■ Planificación de

proceso procesos e hilos
✓ Plani
■Estados del ficaci
proceso ón en
Minix
■Formación de un
✓ Plani
proceso
ficaci
■Concepto de hilo ón en
de ejecución Linux
■Procesos en Minix ✓ Plani
ficaci
Sistemas Operativos II (II-UJI) Procesos e hilos
79
 S O
El planificador de Minix II

■Sistema de colas multinivel (sin realimentación) con prioridades expulsivas

+ TAREAS FCFS

PROCESOS FCFS
PRIORIDAD SERVIDOR

PROCESOS
- USUARIO RR

■Se invoca al planificador (rutina pick_proc) cuando:

◆ Se bloquea un proceso (en ejecución) con SEND o RECEIVE
◆ Tras cada interrupción
◆ Tras la finalización del cuantum de CPU de un proceso de usuario
◆ Al finalizar un proceso
■Implementación del planificador:

rdy_head[TASK_Q]

TAREAS FCFS
+
rdy_head[SERVER_Q]
PROCESOS FCFS
PRIORIDAD SERVIDOR rdy_head[USER_Q]
PROCESOS RR
- USUARIO
■ Implementación del planificador (cont.):

PUBLIC pick_proc ()
{ register int q;/* Cola a usar: */
/* - Cola de tareas: TASK_Q */
/* - Cola de procesos servidor: SERVER_Q */
/* - Cola de procesos de usuario: USER_Q */

if [TASK_Q] != NIL_PROC) q = TASK_Q;

(rdy_head
else if (rdy_head [SERVER_Q] != q = SERVER_Q
NIL_PROC) q = ;
else USER_Q;
prev_proc = cur_proc;
if (rdy_head [q] != NIL_PROC)
{ cur_proc = rdy_head [q]; /* Someone is runable */
} else{
cur_proc = IDLE; /* No one id runable */
 }
}
 S O
Planificación en POSIX II
II

■ Cada política de planificación lleva asociado un rango con al menos

32 niveles de prioridad

■ El planificador elegirá el proceso o hilo con la prioridad más alta

■ Políticas de planificación:
◆ FIFO (FCFS)
◆ Round Robin (RR)
◆ Otra
 S O
El planificador de Linux II

■ Prioridad y algoritmo de planificación de un proceso de Linux:

◆ Todo proceso del sistema tiene asociadas
●una prioridad
●una política de planificación, que puede ser:
 FIFO (SCHED_FIFO)
 RR (SCHED_RR)
 Otra (SCHED_OTHER)

◆ Se asigna política de planificación FIFO y RR a los procesos en

tiempo real (procesos que tienen que reaccionar muy rápidamente a
sucesos externos)
■ Prioridad y algoritmo de planificación de un proceso de Linux (cont.):
◆ Política SCHED_OTHER:
●Favorece procesos interactivos
●Prioridad dinámica = Prioridad_base + (Estimación_CPU_restante / 2)
●Objetivo prioridad base: Dividir los procesos en bandas fijas
de prioridad
■ Algoritmo de planificación:
◆ Algoritmo expulsivo con prioridades (selecciona el proceso con
máxima prioridad)

◆ Los procesos con planificación FIFO y RR tienen mayor prioridad

◆ Un proceso FIFO abandona la CPU cuando:

●Aparece otro proceso listo con mayor prioridad
●El proceso finaliza

◆ Un proceso RR abandona la CPU cuando:

●Aparece otro proceso listo con mayor prioridad
●El proceso finaliza
●Acaba su quantum de CPU y otro proceso tiene igual prioridad (y
es la máxima)
■ Función de planificación:

void schedule(void)
{
int c;
struct task_struct * p, * prev, * next;

prev = current;
Deshabilitar interrupciones
cli();
/* move an exhausted RR process to be last */
if (!prev->counter && prev->policy == SCHED_RR) {
prev->counter = prev->priority;
move_last_runqueue(prev);
}

p = init_task.next_run;
sti();
Habilitar interrupciones
■ Función de planificación (cont.):

/* this is the scheduler proper: */

c = -1000;
next = idle_task;
while (p != &init_task) {
int weight = goodness(p, prev, this_cpu);
if (weight > c)
c = weight, next = p;
p = p->next_run;
}
/* if all runnable processes have "counter == 0",
re-calculate counters */
if (!c) { for_each_task(p)
p->counter = (p->counter >> 1) + p->priority;
}
if (prev != next) { switch_to(prev,next); }
return;
} Cambio de proceso
■ Función de planificación (cont.):

/* This is the function that decides how desirable a process is

* Return values:
* -1000: never select this
* 0: out of time, recalculate counters
* +ve: "goodness" value (the larger, the better)
* +1000: realtime process, select this.
*/

int goodness(struct task_struct * p,

struct task_struct * prev)
{ int weight;
...
if (p->policy != SCHED_OTHER)
return 1000 + p->rt_priority;
■ Función de planificación (cont.):

/ Give the process a first- goodness value

* approximation
* according to the number of clock- it has left.
ticks
* Don't do any other calculations if time slice is over
the */

weight = p->counter;
if (weight) {
/* Give a slight advantage to the current process */
if (p == prev)
weight += 1;
}
return weight;
}
 S O
El planificador de Windows NT/2000 II

■ Prioridad de un hilo:
◆ Dentro del rango 0..31
◆ Depende del tipo de trabajo que esté haciendo
◆ Una cola de hilos listos por cada posible nivel de prioridad

■ Tipos de prioridad:
◆ Prioridades en tiempo real
◆ Prioridades variables
■ Prioridades en tiempo real:
◆ Prioridades más altas (rango 31..16)
◆ Asignadas cuando el tiempo de respuesta del subproceso es crítico
(operaciones de comunicaciones, tareas de tiempo real, etc.)
◆ La prioridad del hilo no cambia nunca
◆ Política RR para los hilos de un nivel de prioridad dado
■ Prioridades variables:
◆ Prioridades más bajas (rango 15..0)
◆ Cola RR en cada nivel de prioridad
◆ Prioridad inicial del hilo:
●Prioridad del proceso + Prioridad base del hilo (-2..+2)
◆ La prioridad del hilo puede variar durante su vida
●No puede ser superior a 15
●No puede ser inferior a la prioridad inicial
●El núcleo baja la prioridad (dinámica) de un hilo cada vez que
finaliza su quantum de CPU asignado
●La prioridad (dinámica) de un hilo aumenta tras una operación de E/S

Los hilos interactivos tienden a prioridades más altas dentro de la clase

de prioridad variable
■ Prioridades variables:
◆ Ejemplo de relación entre prioridades

15
14
13
12
11
10
9
8
7
6 +2 mayor
+1 encima
5 normal
4 0 norm
3 al
2 -1 debajo
1 -2 normal
0
Prioridad Prioridad Prioridad
base del inicial del dinámica
proceso hilo del hilo
■ Algoritmo de planificación de hilos: NIVEL DE
PRIORIDAD
◆ Esquema expulsivo con prioridades 31
y colas multinivel realimentadas .
.
(selecciona el hilo con máxima . .

Prioridades variablesPrioridades en tiempo real

.
prioridad de todas las colas) .
16

15

14
..
.
. .
. .
.
.
0
 “ ■ Servicios POSIX
Tema 2. Procesos e hilos para gestión de procesos
e hilos
S O II
II

Índice
■Concepto de proceso
■Información del proceso
■Estados del proceso
■Formación de un proceso
■Concepto de hilo de ejecución
■Procesos en Minix
■Procesos en Linux
■Procesos en Windows NT/2000
■Planificación de procesos e hilos

Sistemas Operativos II (II-UJI) Procesos e hilos

96
 S O
Servicios POSIX para gestión de hilos II
II
Pthreads
int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destroy (pthread_attr_t *attr);
int pthread_create (pthread_t *thread,
const pthread_attr_t *attr, void *(*func)(void *),
void *arg);
int pthread_exit(void *value);
int pthread_join(pthread_t thid, void **value);
pthread_t pthread_self(void);
int pthread_attr_setdetachstate(pthread_attr_t *attr,
int detachstate);
 S O
Servicios POSIX sobre atributos de hilos II

■ Creación de atributos:
◆ Sintaxis:
int pthread_attr_init(pthread_attr_t *attr);
◆ Descripción:
●Inicia un objeto atributo de tipo pthread_attr_t con las
propiedades que tendrán los hilos que se creen
posteriormente
●Los atributos permiten especificar: tamaño de pila, prioridad,
política de planificación, etc.
●Existen diversas llamadas para modificar los atributos
■ Destrucción de atributos:
◆ Sintaxis:
int pthread_attr_destroy (pthread_attr_t *attr);
◆ Descripción:
●Destruye el objeto atributo de tipo pthread_attr_t pasado como
argumento a la misma
■ Establecimiento del estado de terminación:
◆ Sintaxis:
int pthread_attr_setdetachstate(pthread_attr_t *attr,
int detachstate);
◆ Descripción:
●Establece el estado de terminación de un hilo:
 Si "detachstate" = PTHREAD_CREATE_DETACHED
 El hilo se considerará como “independiente”
 El hilo liberará sus recursos cuando finalice su ejecución

 Si "detachstate" = PTHREAD_CREATE_JOINABLE
 El hilo se considerará como “no independiente”
 El hilo no liberará todos los recursos (descriptor y pila)
cuando finalice su ejecución, es necesario utilizar
pthread_join()
 Habitualmente, valor por defecto
 S O
Servicios POSIX sobre gestión de hilos II

■ Creación de hilos:
◆ Sintaxis:
int pthread_create (pthread_t *thread,
const pthread_attr_t *attr, void *(*func)(void *),
void *arg);
◆ Descripción:
●Crea un hilo con atributos attr que ejecuta func con argumentos arg

■ Finalización de hilos:
◆ Sintaxis:
int pthread_exit(void *value);
◆ Descripción:
●Finaliza la ejecución de un hilo, indicando su estado de terminación
■ Suspensión de hilos:
◆ Sintaxis:
int pthread_join(pthread_t thid, void **value);
◆ Descripción:
●Suspende la ejecución de un hilo hasta que termina el hilo
con identificador thid (no necesariamente un hilo hijo)
●Deja el estado de terminación del hilo en la posición apuntada por
value
●Sólo se puede solicitar este servicio sobre hilos no independientes

■ Identificación de hilos:
◆ Sintaxis:
pthread_t pthread_self(void);
◆ Descripción:
●Devuelve el identificador del hilo que ejecuta la llamada
 ■ Jerarquía de hilos:
Hilo principal (main)
Hilo 1

pthread_create pthread_create pthread_create

Hilo 4 Hilo 3 Hilo 2

No
independiente
pthread_exit
pthread_join

pthread_exit
 S O
Servicios POSIX para gestión de hilos II
■ Ejemplo 1:
#include <pthread.h>
#include <stdio.h>
void *hilo(void *cadena)
{
int i;
for (i=0; i<10; i++)
printf("Hilo (%d): %d %s \n",pthread_self(),i,(char *)cadena);
pthread_exit(0);
}
int main() A partir de aquí, el hilo principal, hilo1 e
{ hilo2 se ejecutan concurrentemente.
char *cadena1="Hola"; Cualquiera puede acabar 1°, 2°o último
char *cadena2="Adios";
pthread_t hilo1, hilo2;
pthread_create(&hilo1, NULL, hilo, (void *)cadena1);
pthread_create(&hilo2, NULL, hilo, (void *)cadena2);
exit(0);
}
■ Ejemplo 2:
#include <pthread.h>
¡Ojo a la exclución mutua!
#include <stdio.h>
int cont=0;
void *hilo(void *arg)
{ sleep(2);
cont=cont+1;
printf("Hilo (%d): cont=%d \n",pthread_self(),cont);
pthread_exit(0);
}
int main()
{ pthread_t hilo1, hilo2;
printf("Hilo principal (%d): cont=%d \n",pthread_self(),cont);
pthread_create(&hilo1, NULL, hilo, NULL);
pthread_create(&hilo2, NULL, hilo, NULL);
pthread_join(hilo1,NULL); /* Punto de sincronización con hilo1 */
/* Hilo2 sigue su marcha. Puede o no haber acabado*/
pthread_join(hilo2,NULL); /* Punto de sincronización con hilo2 */
printf("Hilo principal (%d): cont=%d
\n",pthread_self(),cont); exit(0);
}
 S O
Servicios POSIX para gestión de procesos II
II
■ Ejemplo 2: Código pseudo-equivalente con gestión de procesos pesados:
#include <stdio.h>
int main() ¿Por qué?
{ int estado, cont=0;
printf("Padre (%d): cont=%d
\n",getpid(),cont); if (fork() != 0)
{
if (fork() != 0)
{ wait(&estado);
wait(&estado);
printf("Padre (%d): cont=%d \n",getpid(),cont);
} else { /* HIJO 2 */
cont=cont+1;
printf("Hijo 2 (%d): cont=%d \n",getpid(),cont);
}
} else { /* HIJO 1 */
cont=cont+1;
printf("Hijo 1 (%d): cont=%d \n",getpid(),cont);
}
exit(0);
}
 S O
Servicios POSIX para gestión de hilos II
■ Ejemplo 3:
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>
int x=0;
void *fhilo1(void *arg) void *fhilo2(void *arg)
{ int i, cont; { int i, cont;
for (i=0; i<3; i++) { for (i=0; i<3; i++)
{ cont=x+1; cont=x-1;
printf (“Suma 1\n”); printf (“Resta 1\n”);
sleep (random()%3); sleep (random()%3);
x=cont; x=cont;
} }
pthread_exit (NULL); pthread_exit (NULL);
} }
■ Ejemplo 3 (cont.):
main()
{ pthread_t hilo1, hilo2;
time_t t;
srandom (time(&t);
printf ("Valor inicial de x: %d \n",x);
pthread_create(&hilo1, NULL, fhilo1, NULL);
pthread_create(&hilo2, NULL, fhilo2, NULL);
pthread_join(hilo1,NULL);
pthread_join(hilo2,NULL);
printf ("Valor final de x: %d \n",x);
exit(0);
}

¿Funcionamiento correcto?
 S O
Ejercicios II
■ Ejercicio 1:
Realizar un algoritmo o programa en el que, dado el número de identificación de
un proceso, se obtenga el número de hijos que tiene dicho proceso y sus
correspondientes números de identificación.
■ Ejercicio 1 (solución):
Solución I:

void muetra_hijos (int pidPadre);

{struct task_struct *p;
int n_hijos=0;
p=&init_task->next_task;
while ((p->pid!=pidPadre) && (p!=&init_task))
p=p->next_task;
if (p==&init_task) return (-1);
if (p=p->cptr!=NULL)
do
printf (“%d \n”,p-> pid);
n_hijos++1;
while (p=p->p_osptr!=NULL);
printf (“El proceso %d tiene %d hijos \n”,pidPadre,n_hijos);
return (0);
}
■ Ejercicio 1 (solución):
Solución II:

void muetra_hijos (int pidPadre);

{struct task_struct *p;
int n_hijos=0;
p=&init_task->next_task;
while ((p->pid!=pidPadre) && (p!=&init_task))
p=p->next_task;
if (p==&init_task) return (-1);
for each_task (p)
if (p->p_pptr->pid==pidPadre)
{printf (“%d \n”,p->p_pptr->pid);
n_hijos++1;}
printf (“El proceso %d tiene %d hijos\n”,pidPadre,n_hijos);
return (0);
}
■ Ejercicio 2:
Desarrollar un algoritmo o un programa que genere una salida similar a la del
comando pstree en el sistema operativo Linux.

void pstree2 ();

{struct task_struct *p;
void pstree2_rec (struct task_struct *h);
{ hh=h->p_cptr;
while (hh!=NULL)
{ printf (“Proc padre %d. Proc hijo %d\n”,h->pid,hh->pid);
pstree2_rec (hh);
hh=hh->p_osptr;
}
return (0);
}
p=&init_task;
pstree2_rec (p);
return (0);
}
■ Ejercicio 3:
Desarrollar un algoritmo o un programa que calcule de la forma más
eficiente posible el número de procesos huérfanos que hay en un sistema
Linux en un instante dado.
■ Ejercicio 4:
Desarrollar un algoritmo o un programa en el que, dado el número de
identificación de un proceso Linux, se muestre el proceso hijo preparado
para ejecución (en estado listo) que lleva más tiempo ejecutándose, ya sea
en modo usuario o supervisor.
 ■ Ejercicio 5:
Supongamos que, en un instante dado, la lista de procesos preparados para
ejecución de un sistema operativo linux es la que aparece a continuación y
que el proceso en ejecución es el proceso 3. ¿Qué proceso pasaría a
ejecución si se invoca al planificador de linux? Justificar la respuesta.

Proceso init Proceso 1 Proceso 2 Proceso 3 Proceso 4 Proceso 5 Proceso 6 Proceso 7 Proceso 8
... ... ... ... ... ... ... ... ...
Política planificación FIFO RR RR
Prioridad dinámica OTHER FIFO
FIFO OTHER RR 25 20 25 20 25
Prioridad estática 20 50 0
... 20 75 25 25 25 25 20 25
... ... ... ... ... ... ... ...
■ Ejercicio 5 (solución):

1. El proceso 3 se mueve al final de la lista

2. La función goodness proporciona las siguientes prioridades a
los procesos de la lista de procesos listos:

FIF Oth FIF RR RR Oth FIF RR

O er O er O
Proces P1 P2 P4 P5 P6 P7 P8 P3
o
Weight 1020 50 102 102 102 20 102 102
5 5 5 5 5

3. Tras el bucle while c=1025 y next apunta al proceso P4

■ Ejercicio 6:
¿Qué proceso seleccionaría el planificador de linux en un instante dado en
el que hay dos procesos con la máxima prioridad y uno tiene asignada la
política FIFO y otro RR?

Solución:
El primero que se encuentre en la lista (ver ejemplo del ejercicio 5).
■ Ejercicio 8:
¿En qué variaría la política de planificación de procesos de linux si en
la función schedule se sustituye la línea

if (weight > c)
por lo siguiente:
?
if (weight >= c)
Solución:
En este caso, ante varios procesos con máxima prioridad se seleccionaría
el último de ellos que esté en la lista de procesos listos del sistema.
Consecuentemente, si estos procesos con la máxima prioridad tuviesen
asignada una política de planificación FIFO, dejaría que cumplirse
dicha política. Y lo mismo ocurriría con la política de planificación RR.
■ Ejercicio 9:
Explicar cómo se cumple la política FIFO en el planificador de procesos de
linux cuando varios procesos con este tipo de política tienen la máxima
prioridad.
■ Ejercicio 9 (solución):
Veámoslo con el siguiente ejemplo:
PROCESO P1 P2 P3 P4 P5 P6 P7 P8
Política FIFO RR FIFO Oth Oth FIFO RR FIFO
er er
Prior. Estática 50 40 50 80 60 30 25 50
Prior. 50 30 50 75 60 30 20 50
Dinámica
Weight 1050 1040 1050 75 60 1030 1025 1050

Tras el bucle while c=1050 y next apunta al proceso P1. Si no apareciesen más
procesos listos, cuando acabe la ejecución del proceso P1 el planificador
seleccionará al siguiente proceso de la lista más prioritario, esto es, P3, que
entró después de P1 en la lista. Si no hubiesen aparecido más procesos listos,
cuando P3 finalice el proceso más prioritario sería P8, que había entrado en la
lista tras P1 y P3. Resumiendo, los tres procesos FIFO con la prioridad máxima
se ejecutan en el orden en que entraron en la lista.
■ Ejercicio 10:
Explicar la validez del siguiente código:
#include <pthread.h>
#include <stdio.h>
#define MAX_THREADS 10
void *imprimir(int *n)
{ sleep (3);
printf("Hilo (%d): %d \n",pthread_self(),*n);
pthread_exit(0);
}
int main()
{ int num;
pthread_t hilo;
pthread_attr_t attr;
pthread_attr_init (&attr);
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
while (1) {
scanf (“%d”, &num);
pthread_create(&hilo, &attr, imprimir, &num);
exit(0);
}