Silo - Tips Tema 2 Procesos e Hilos

SO
Tema 2. Procesos e hilos 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
■ Servicios POSIX para gestión de procesos e hilos
Sistemas Operativos II (II-UJI) 1 Procesos e hilos

SO
II
Índice
✓ 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
✓ Objetos tipo proceso e hilo
✓ Estados de un hilo
✓ Implementación del procesos e hilos

SO
II
Índice
✓ Planificación en Minix
✓ Planificación en Linux
✓ Planificación en Windows NT/2000

SO
II
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.

SO
II
Índice
☛ ■ Concepto de proceso

SO
II
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
Datos
-Zonas de memoria
-Ficheros PC
Código
-Dispositivos, etc.
Programa: estructura pasiva Proceso: estructura activa

SO
II
■ Jerarquía de procesos:
◆ Algunos SO, como Unix, mantienen una estructura jerárquica entre
procesos
init
Inicio Inicio Inicio Inicio Dem. Impr. Dem. Com..
Shell Shell
Proceso init:
● PID = 1
Proceso A
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

SO
II
■ 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

SO
II
■ 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
...

SO
II
■ 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

SO
II
Índice
☛ ■ Información del proceso

SO
II
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)

SO
II
Información del proceso II
Registros
Mapa de memoria
especiales del Proceso A
Mapa de memoria Tablas del sistema operativo

del Proceso B
Tabla de procesos
Registros Mapa de memoria BCP Proceso A BCP Proceso B BCP Proceso C
generales del Proceso C - Estado (registros) - Estado (registros) - Estado (registros)
- Identificación - Identificación - Identificación
- Control - Control - Control
Tablas SO - Tabla de memoria
PC - Tabla de E/S
- Tabla de ficheros
SP Mapa de
Estado Memoria

SO
II
Estado del procesador 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

SO
II
Preparación del código de un proceso II
Problema
Editor
Módulo Módulo
fuente A fuente B
Compilador o
ensamblador
Módulo Módulo Otros

objeto A objeto B objetos
Montador
Objeto Bibliotecas
ejecutable del sistema
Cargador
Ejecutable en
memoria

SO
II
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

SO
II
Imagen de memoria II
■ Imagen de memoria de un proceso en un sistema con memoria virtual:
Registro identificador de estado de

direccionamiento
RIED
Memoria
Memoria
principal
virtual
Código
Datos Tamaño
Disco
Tabla de
Pila páginas
Una tabla de páginas por

proceso

SO
II
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

Tabla de ficheros abiertos
■ Información de control del proceso: 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

SO
II
■ ¿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

SO
II
■ 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

SO
II
Compartir información II
BCP 4 BCP 7 BCP 23

Tabla de Tabla de Tabla de
ficheros ficheros ficheros
0 23 0 23 0 54
fd 1 4563 fd 1 4563 fd 1 633
2 56 2 56 2 5368
3 4 3 4 3 33
4 678 4 0 4 2
IDFF PP
1 24456 0 ● El proceso con BCP7 es hijo del proceso con BCP4
2 34512 2345
3 28 5566 ● Los procesos con BCP7 y BCP4 comparten
4 34512 10000
punteros a los mismos ficheros
● El proceso con BCP23 abre uno de los ficheros
Tabla de ficheros compartido por los procesos con BCP7 y BCP4
del sistema
IDFF = Identificativo de fichero
PP = Posición puntero al fichero

SO
II
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

SO
II
Tablas del SO II
■ 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

SO
II
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”)

SO
II
Usuarios y grupos reales y efectivos II
■ 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—--

SO
II
Índice
☛ ■ Estados del proceso

SO
II
Estados de un proceso II
■ Cuando un proceso se ejecuta pasa por distintintos estados
■ Diagrama de transición entre estados:
Ejecución Exit
Es
p er
U a
CP ev por
A U en E
CP
to /S
o
n
sió
p ul
Ex
Fin E/S o llegada evento

Listo Bloqueado

SO
II
Estados de un proceso II
■ Estados suspendidos:
Exit
Ejecución
Es
o pe
ad
n if
ic
o ra p
Memoria
Pla ido ev or
um en E
ns to /S
co
po
iem
T
Listo Fin E/S o llegada evento Bloqueado
Recuperado del disco
Expulsado al disco
Expulsado al disco
Entra al
sistema
intercambio
Zona de
Listo y Fin E/S Bloqueado y
Procesos por lotes suspendido suspendido
en espera

SO
II
Índice
☛ ■ Formación de un proceso

SO
II
Formación de un proceso II
Mapa de
memoria Tabla de procesos
Objeto Ca rg a d o r
Imagen BCP
ejecutable
del proceso
Biblioteca
sistema

SO
II
Índice
☛ ■ Concepto de hilo de ejecución

SO
II
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.

SO
II
■ ¿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.

SO
II
■ ¿Qué es un hilo de ejecución (cont.)?
Pila 1
Otros recursos:
Hilo 1 -Ficheros abierto
-Dispositivos E/S, etc.
Pila2
Proceso
Hilo 2
Datos
Código PC2
PC1
Hilo: unidad de planificación Proceso: unidad de asignación de recursos

SO
II
■ 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

SO
II
■ 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.

SO
II
Estados de un hilo y de un proceso 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

SO
II
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
Ejecución
P F P F
Espera Espera serie
en E/S en E/S
Procedimiento 1
P F
Espera
en E/S Ejecución
Procedimiento 2 paralela
P F Procesamiento
Espera
en E/S

SO
II
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)

SO
II
■ 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

SO
II
■ Ejemplo (cont.): Servidor de ficheros con múltiples hilos
Hilo distribuidor Hilo trabajador
Algoritmo 1 Algoritmo 2
Mientras no haya que terminar { Mientras no haya que terminar {
Esperar a que llegue una petición Esperar trabajo
Esperar trabajador libre Comprobar que la petición es correcta
} Si (los datos no están en la caché) {
Enviar resultado Realizar operación de E/S
} bloqueante sobre disco
}
Enviar resultado
Avisar que está libre
}
● Mayor complejidad
● Buenas prestaciones

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

mismo proceso.
Proceso
Mono
Proce Hilo
Sado Un proceso Un proceso
Un hilo/proceso Múltiples hilos/proceso
res
Ej: MS-DOS Ej: Java
Multi
Proce
sado
res Múltiples procesos Múltiples procesos
Un hilo/proceso Múltiples hilos/proceso
Ej: Algunos UNIX Ej: Windows 2000, Solaris, OS/2
Técnica monohilo Técnica multihilo

SO
II
Implementación de hilos II
■ Dos categorías:
◆ Hilos a nivel de usuario
◆ Hilos a nivel de núcleo

SO
II
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

SO
II
Hilos a nivel de usuario II
■ 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.

SO
II
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 núcleo

Modo usuario
Modo supervisor P Proceso

SO
II
Hilos a nivel de núcleo II
■ 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.

SO
II
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.

SO
II
Aproximaciones combinadas II
■ Ejemplo: Solaris (cont.)
Hilo a nivel de núcleo

Biblioteca de hilos
Modo usuario
Modo supervisor P Proceso
P P

SO
II
Modelos multihilo 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)

SO
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.

SO
II
Índice
☛ ■ Procesos en Minix

SO
II
Procesos en Minix II
■ Diagrama de transición entre estados:
En ejecución
unready
pick_proc
sched
Listo Bloqueado
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 ejecución pues
éste ha agotado su quantum de CPU

SO
II
■ Descriptor de un proceso:
EXTERN struct proc{

int p_reg[NR_REGS]; /* process’ registers */
int *p_sp; /* stack pointer */
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 */

SO
II
■ Descriptor de un proceso (cont.):
struct proc *p_callerq; /* head of list of procs wishing to send */

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

int p_pending; /* bit map for pending signals */
} proc[NR_TASKS+NR_PROCS];

SO
II
Índice
☛ ■ Procesos en Linux
✓ Implementación de la tabla de procesos
✓ Implementación de la lista de procesos preparados

SO
II
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

SO
II
■ Descriptor de un proceso:
◆ Estructura task_struct del fichero include/linux/sched.h
■ Estado del proceso:

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

#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

SO
II
■ Identificativos del proceso:

pid_t pid; /* Identificativo del proceso */
pid_t pgrp; /* Identificativo del grupo del proceso*/
pid_t session; /* Número de sesión del proceso */
uid_t uid,euid; /* Identificativo real y efectivo del usuario */
gid_t gid,egid; /* Identificativo real y efectivo del grupo */
gid_t groups[NGROUPS]; /* Lista grupos a los que pertenece el proceso */

SO
II
■ Planificación del proceso:

unsigned long policy; /* Tres posibles políticas de planificación */
#define SCHED_FIFO 1
#define SCHED_RR 2
#define SCHED_OTHER 0
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

SO
II
■ Jerarquía del proceso:

struct task_struct *p_opptr; /* Original parent */
struct task_struct *p_pptr; /* Parent */
struct task_struct *p_cptr; /* Youngest child */
struct task_struct *p_ysptr; /* Younger sibling */
struct task_struct *p_osptr; /* Older sibling */
ptr padre
c
p_ p_p
tr ptr
pp
p_
p_pptr
p_osptr p_osptr
hijo más hijo más
joven hijo viejo
p_ysptr p_ysptr

SO
II
■ Señales del proceso:

struct sigset_t signal; /* Mapa de bits de señales recibidas */
struct sigset_t blocked; /* Mapa de bits de señales bloqueadas */
struct sigset_t sigpending; /* Mapa de bits de señales no 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 */

SO
II
■ Monitorización del proceso:

long per_cpu_utime[NR_CPU]; /* Tiempo del proceso en modo usuario */
long per_cpu_stime [NR_CPU]; /* Tiempo del proceso en modo supervisor */
long start_time; /* Tiempo de creación del proceso */
/* Tiempos sobre temporizadores y alarmas */

unsigned long it_real_value; /* Tiempo real */
unsigned long it_prof_value, /* Tiempo en ejecución o estado listo */
unsigned long it_virt_value; /* Tiempo en ejecución sin contar la
ejecución de llamadas al sistema */
struct timer_list real_timer; /* Lista de alarmas */
¿Temporizador vs. Alarma?

SO
II
■ Segmentos de memoria del proceso:

struct mm_struct *mm;
struct mm_struct {
...
struct vm_area_struct *mmap;
struct vm_area_struct *mmap_avl;
struct vm_area_struct *mmap_cache;
unsigned long start_code, end_code; /* Dirección de inicio y fin del

segmento de código */
unsigned long start_data, end_data; /* Dirección de inicio y fin del
segmento de datos */
unsigned long start_stack; /* Dirección del tope del segmento
de pila de usuario */
...
};

SO
II
■ 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*/
};

SO
II
■ Sistema de ficheros del proceso (cont.):
0 ...
1 1 READ
... 1 /etc/passwd
2
3 1 WRITE
4 1 READ 2 /usr/castano
...
5
...
6
Tabla de ficheros Tabla de ficheros Tabla de inodos
del proceso del sistema

SO
II
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

SO
II
■ 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

SO
II
■ 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 ; )

SO
II
Índice
☛ ■ Procesos en Windows NT/2000
✓ Objetos tipo proceso e hilo
✓ Estados de un hilo
✓ Implementación del procesos e hilos

SO
II
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

SO
II
Tipo del
■ Objeto tipo proceso:
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
Abrir proceso
del objeto
Servicios
Pedir información del proceso

Añadir información del proceso
Finalizar proceso
Asignar/liberar memoria virtual
Leer/escribir memoria virtual
etc.

SO
II
■ 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

SO
II
Tipo del
■ Objeto tipo hilo:
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 hilo
Abrir hilo
del objeto
Servicios
Pedir información del hilo

Añadir información del hilo
Finalizar hilo
Suspender/continuar hilo
Guardar/cargar contexto
etc.

SO
II
■ 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

SO
II
■ Diagrama de transición entre estados (de un hilo):
Inicializado
Reinicializar
Finalizado nto Listo

Eve
Planificador
Finalización
Expulsar
Bloqueado
Esperar evento
lsar
Ejecución Expu Alerta
A CPU

SO
II
■ 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

SO
II
■ 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
.
.

SO
II
Índice
■ Procesos en Windows NT/2000 ✓ Planificación en Minix
☛ ■ Planificación de procesos e hilos ✓ Planificación en Linux
✓ Planificación en Windows NT/2000

SO
II
El planificador de Minix II
■ Sistema de colas multinivel (sin realimentación) con prioridades expulsivas
+ TAREAS FCFS
PROCESOS FCFS
PRIORIDAD SERVIDOR
PROCESOS RR
- USUARIO
■ 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

SO
II
■ 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

SO
II
■ 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 (rdy_head [TASK_Q] != NIL_PROC) q = TASK_Q;

else if (rdy_head [SERVER_Q] != NIL_PROC) q = SERVER_Q;
else q = 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 */
}
}

SO
II
Planificación en POSIX 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

SO
II
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)

SO
II
■ 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

SO
II
■ 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)

SO
II
■ 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

SO
II
■ 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

SO
II
/* 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;

SO
II
/* Give the process a first-approximation goodness value

* according to the number of clock-ticks it has left.
* Don't do any other calculations if the time slice is over */
weight = p->counter;
if (weight) {
/* Give a slight advantage to the current process */
if (p == prev)
weight += 1;
}
return weight;
}

SO
II
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

SO
II
■ 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

SO
II
■ 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

SO
II
■ Prioridades variables:
◆ Ejemplo de relación entre prioridades
15
14
13
12
11
10
9
8
7
6 +2 mayor
5 +1 encima normal
4 0 normal
3 -1 debajo normal
2 -2 menor
1
0
Prioridad Prioridad Prioridad
base del inicial del dinámica
proceso hilo del hilo

SO
II
■ Algoritmo de planificación de hilos: NIVEL DE

PRIORIDAD
◆ Esquema expulsivo con prioridades 31
Prioridades en
y colas multinivel realimentadas
tiempo real
. .
.
(selecciona el hilo con máxima .
.
.
prioridad de todas las colas)
16
15
Prioridades
variables
14
.
. .
. .
.
.
.
.
0

SO
II
Índice
☛ ■ Servicios POSIX para gestión de procesos e hilos

SO
II
Servicios POSIX para gestión de hilos 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);

SO
II
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

SO
II
■ 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

SO
II
■ 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

SO
II
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

SO
II
■ 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

SO
II
■ 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

SO
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);
}

SO
II
■ 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);
}

SO
II
Servicios POSIX para gestión de procesos II
■ Ejemplo 2: Código pseudo-equivalente con gestión de procesos pesados:

#include <stdio.h> ¿Por qué?
int main()
{ 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);
}

SO
II
■ Ejemplo 3:
#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);
} }

SO
II
■ 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?

SO
II
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.

SO
II
Ejercicios II
■ 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);
}

SO
II
Ejercicios II
Solución II:
void muetra_hijos (int pidPadre);

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);
}

SO
II
Ejercicios II
■ 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 ();

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);
}

SO
II
Ejercicios II
■ 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.

SO
II
Ejercicios II
■ 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.

SO
II
Ejercicios II
■ 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.
r er ity
nte nt r rity
u it y u io
co rior co _pr prio
p rt rt_
Proceso init Proceso 1 Proceso 2 Proceso 3 Proceso 4 Proceso 5 Proceso 6 Proceso 7 Proceso 8
... ... ... ... ... ... ... ... ...
Política planificación FIFO OTHER RR FIFO RR RR OTHER FIFO
Prioridad dinámica 20 50 0 25 20 25 20 25
Prioridad estática 20 75 25 25 25 25 20 25
... ... ... ... ... ... ... ... ...

SO
II
Ejercicios II
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:
FIFO Other FIFO RR RR Other FIFO RR

Proceso P1 P2 P4 P5 P6 P7 P8 P3
Weight 1020 50 1025 1025 1025 20 1025 1025
3. Tras el bucle while c=1025 y next apunta al proceso P4

SO
II
Ejercicios II
■ 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).

SO
II
Ejercicios II
■ 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.

SO
II
Ejercicios II
■ 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.

SO
II
Ejercicios II
Veámoslo con el siguiente ejemplo:
PROCESO P1 P2 P3 P4 P5 P6 P7 P8
Política FIFO RR FIFO Other Other FIFO RR FIFO
Prior. Estática 50 40 50 80 60 30 25 50
Prior. Dinámica 50 30 50 75 60 30 20 50
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.

SO
II
Ejercicios II
■ Ejercicio 10:
Explicar la validez del siguiente código:
#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);
}

Silo - Tips Tema 2 Procesos e Hilos

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Silo - Tips Tema 2 Procesos e Hilos

Cargado por

Copyright:

Formatos disponibles

SO

Tema 2. Procesos e hilos II

Sistemas Operativos II (II-UJI) 1 Procesos e hilos

Sistemas Operativos II (II-UJI) 2 Procesos e hilos

Sistemas Operativos II (II-UJI) 3 Procesos e hilos

Sistemas Operativos II (II-UJI) 4 Procesos e hilos

Sistemas Operativos II (II-UJI) 5 Procesos e hilos

Programa: estructura pasiva Proceso: estructura activa

Sistemas Operativos II (II-UJI) 6 Procesos e hilos

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

Proceso B Proceso D Proceso C

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

Sistemas Operativos II (II-UJI) 7 Procesos e hilos

■ El proceso nulo (o la tarea ociosa):

◆ ¿Qué hace el proceso nulo?

● En sistemas Unix suele tener PID=0

Sistemas Operativos II (II-UJI) 8 Procesos e hilos

■ Entorno del proceso:

● Mediante mandatos del shell (

Sistemas Operativos II (II-UJI) 9 Procesos e hilos

◆ Se pueden realizar ciertas operaciones sobre un grupo de procesos

Sistemas Operativos II (II-UJI) 10 Procesos e hilos

Sistemas Operativos II (II-UJI) 11 Procesos e hilos

■ Estado del procesador:

■ Bloque de control de proceso (BCP)

Sistemas Operativos II (II-UJI) 12 Procesos e hilos

Mapa de memoria Tablas del sistema operativo

Sistemas Operativos II (II-UJI) 13 Procesos e hilos

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

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

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

Sistemas Operativos II (II-UJI) 14 Procesos e hilos

Módulo Módulo Otros

Sistemas Operativos II (II-UJI) 15 Procesos e hilos

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

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

Sistemas Operativos II (II-UJI) 16 Procesos e hilos

■ Imagen de memoria de un proceso en un sistema con memoria virtual:

Registro identificador de estado de

Una tabla de páginas por

Sistemas Operativos II (II-UJI) 17 Procesos e hilos

■ Estado del procesador

Sistemas Operativos II (II-UJI) 18 Procesos e hilos

■ ¿Qué información del proceso se saca fuera del BCP?

Sistemas Operativos II (II-UJI) 19 Procesos e hilos

■ Punteros de posición de los ficheros:

Sistemas Operativos II (II-UJI) 20 Procesos e hilos

BCP 4 BCP 7 BCP 23

Sistemas Operativos II (II-UJI) 21 Procesos e hilos

■ 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

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

Sistemas Operativos II (II-UJI) 22 Procesos e hilos

■ Implementación de una cola de procesos listos:

Cola de procesos Inicio

Sistemas Operativos II (II-UJI) 23 Procesos e hilos

■ Usuarios reales y efectivos:

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

◆ EGID (“effective group identifier”)

Sistemas Operativos II (II-UJI) 24 Procesos e hilos

chmod 4511 (ó chmod u+s)

Sistemas Operativos II (II-UJI) 25 Procesos e hilos

Sistemas Operativos II (II-UJI) 26 Procesos e hilos