so ii tema 2. procesos e hilos -...

Sistemas Operativos II (II-UJI) Procesos e hilos1

SS OOIIIIIIII

Tema 2. Procesos e hilos

Índice

n Concepto de proceso

n Información del proceso

n Estados del proceso

n Formación de un proceso

n Concepto de hilo de ejecución

n Procesos en Minix

n Procesos en Linux

n Procesos en Windows NT/2000

n Planificación de procesos e hilos

n Servicios POSIX para gestión de procesos e hilos


SS OOIIIIIIII


Índice

n Procesos en Minix3 Estados de un proceso3 Implementación del descriptor de proceso

n Procesos en Linux3 Estados de un proceso3 Implementación del descriptor de proceso3 Implementación de la tabla de procesos3 Implementación de la lista de procesos preparados

n Procesos en Windows NT/20003 Objetos tipo proceso e hilo3 Estados de un hilo3 Implementación del procesos e hilos


SS OOIIIIIIII


Índice

n Planificación de procesos e hilos3 Planificación en Minix3 Planificación en Linux3 Planificación en Windows NT/2000


SS OOIIIIIIII

Bibliografía

n J. Carretero et al. Sistemas Operativos: Una Visión Aplicada. McGraw-Hill. 2001. Capítulo 3

n W. Stallings. Sistemas Operativos. Prenctice-Hall. 2001. Capítulos 3, 4, 9 y 10

n A.S. Tanenbaum, A.S. Woodnull. Operating Systems. Design and Implementation. Prentice-Hall International, 2a. edición. 1996.

n H. Custer. Inside Windows NT. Microsoft Press. 1993.



SS OOIIIIIIII


Índice






n Procesos en Minix

n Procesos en Linux




*


SS OOIIIIIIIIConcepto de proceso

n ¿Qué es un proceso?

u Instancia de un programa en ejecución, requiriendo para ello unos recursos

Programa: estructura pasiva Proceso: estructura activa

Proceso

PC

Recursos:-Procesador-Zonas de memoria-Ficheros -Dispositivos, etc.

Programa Pila

Datos

Código

Otros recursos:-Ficheros abierto-Dispositivos E/S, etc.



n Jerarquía de procesos:

u Algunos SO, como Unix, mantienen una estructura jerárquica entre procesos

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

Proceso init: l PID = 1l Ancestro de todos los procesos

init

Inicio Inicio

ShellShell

Editor

Dem. Impr. Dem. Com..

Proceso A

Proceso B Proceso D Proceso C

Proceso E Proceso F

InicioInicio



n El proceso nulo (o la tarea ociosa):

u ¿Qué ocurre cuando el procesador está ocioso?l Se ejecuta el proceso nulo

u ¿Qué hace el proceso nulo?l Ejecuta un bucle infinito que no realiza ninguna operación útill En sistemas Unix suele tener PID=0

u Objetivo:l Entretener al procesador cuando no hay ninguna otra tarea



n Entorno del proceso:

u Tabla NOMBRE-VALOR que se pasa al proceso en su creación

u Se incluye en la pila

u Se establece:l Por defectol Mediante mandatos del shell (export)l Mediante API del SO (putenv, getenv )

u Ejemplo de entorno de un proceso en Unix:l $envLOGNAME=castanoSHELL=/bin/bashTERM=vt100HOME=/users/icc/castanoPATH=/usr/local/bin:/bin:/usr/bin:/users/castano/bin...



n Grupos de procesos:

u Los procesos forman grupos de procesos con alguna característicacomún

l Conjunto de procesos creados por el mismo padrel Conjunto de procesos creados a partir de un shelll Conjunto de procesos dependientes de un terminal

u Se pueden realizar ciertas operaciones sobre un grupo de procesos

l Matar todos los procesos de un grupo de procesosl Envío de señales a todos los procesos de un grupo de procesos


SS OOIIIIIIII


Índice






n Procesos en Minix

n Procesos en Linux




*


SS OOIIIIIIIIInformación del proceso

n Estado del procesador:

u Contenido de los registros del modelo de programación

n Imagen de memoria:

u Contenido de los segmentos de memoria en los que reside el código y los datos del proceso

n Bloque de control de proceso (BCP)


SS OOIIIIIIIIInformación del proceso

Mapa deMemoria

Mapa de memoriadel Proceso A

Tablas SOPC

SP

Estado

Mapa de memoriadel Proceso B

Mapa de memoriadel Proceso C

Registrosgenerales

Registrosespeciales

Tablas del sistema operativoTabla de procesos

- Tabla de memoria- Tabla de E/S- Tabla de ficheros

BCP Proceso BBCP Proceso A BCP Proceso C-- Identificación- Control

Estado (registros)-- Identificación- Control

Estado (registros) -- Identificación- Control

Estado (registros)


SS OOIIIIIIIIEstado del procesador

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

u Registros generalesu Contador de programau Puntero de pilau Registro de estadou Registros especiales

n Cuando un proceso está ejecutando su estado del procesador reside en los registros del computador

n Cuando un proceso no se está ejecutando su estado del procesador reside en el BCP


SS OOIIIIIIIIPreparación del código de un proceso

Módulofuente A

Módulofuente B

Compilador oensamblador

Móduloobjeto A

Móduloobjeto B

Otrosobjetos

Montador

Objetoejecutable

Cargador

Editor

Ejecutable enmemoria

Problema

Bibliotecasdel sistema


SS OOIIIIIIIIImagen de memoria

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

n La memoria del proceso la asigna el gestor de memoria del SO

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

n La imagen de memoria, dependiendo del computador, puede estar referida a memoria virtual o memoria física


SS OOIIIIIIIIImagen de memoria

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

Memoriavirtual

Código

Datos

Pila

Disco

Memoriaprincipal

Tabla depáginas

Una tabla de páginas por proceso

RIED

Tamaño

Registro identificador de estado de direccionamiento


SS OOIIIIIIIIInformación del BCP

n Información de identificación:u PID del proceso, PID del padreu ID de usuario real (uid real)u ID de grupo real (gid real)u ID de usuario efectivo (uid efectivo)u ID de grupo efectivo (gid efectivo)

n Estado del procesador

n Información de control del proceso:u Información de planificación y estadou Descripción de los segmentos de memoria del procesou Recursos asignados (ficheros abiertos, ...)u Comunicación entre procesos (señales, ...)u Punteros para estructurar los procesos en listas o colas

Tabla de ficheros abiertos por el proceso



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

u La que tiene tamaño variable

l Ejemplo: Tabla de páginas

l Razones de eficiencia

l La tabla de procesos se construye como una estructura estática, formada por un número de BCP del mismo tamaño

u La que se comparte:

l El BCP es de acceso restringido al proceso que lo ocupa

l Ejemplo: Punteros de posición de ficheros abiertos por el proceso



n Tabla de páginas:

u Describe la imagen de memoria del procesou Tamaño variableu El BCP contiene el puntero a la tabla de páginasu La compartición de memoria requiere que sea externa al BCP

n Punteros de posición de los ficheros:

u Si se asocian a la tabla de ficheros abiertos por los procesos (en el BCP) no se pueden compartir

u Si se asocian al i-nod se comparten siempreu Se ponen en una estructura común a los procesos y se asigna uno

nuevo en cada servicio open


SS OOIIIIIIIICompartir información

l El proceso con BCP7 es hijo del proceso con BCP4

l Los procesos con BCP7 y BCP4 comparten punteros a los mismos ficheros

l El proceso con BCP23 abre uno de los ficheros compartido por los procesos con BCP7 y BCP4

Tabla deficheros

BCP 4 BCP 7 BCP 23

23 23

24456IDFF PP

0

544563 4563

34512 2345

63356 56

28 5566

53684 4

34512 10000

33678 2

0 0 01 1

1

12 2

2

23 3

3

34 4

4

4

fd

0

fd fd

Tabla deficheros

Tabla deficheros

Tabla de ficheros del sistema

IDFF = Identificativo de ficheroPP = Posición puntero al fichero


SS OOIIIIIIIITablas del SO

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

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

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

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


SS OOIIIIIIIITablas del SO

n Implementación de una cola de procesos listos:

Proceso 7

Proceso 5

Proceso 3

Proceso 9

Inicio

Tabla de procesosTabla de procesos

Cola de procesos Cola de procesos listoslistos Fin

BCP 1

BCP 2

BCP 3

BCP 4


SS OOIIIIIIIIUsuarios y grupos reales y efectivos

n Usuarios reales y efectivos:

u UID (“real user identifier”): Identificativo real del usuarioUsuario responsable del proceso en ejecución

u EUID (“effective user id.”): Identificativo efectivo del usuarioSe usa para:

Π Acceder a ficheros de otros usuariosΠ Enviar señales a procesosΠ Ejecutar programas “setuid”

n Grupos reales y efectivos:

u GID (“real group identifier”):

u EGID (“effective group identifier”)


SS OOIIIIIIIIUsuarios y grupos reales y efectivos

n Programas “SETUID”:

u 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

u Ejemplos de programas “setuid”: login, mount, passwd, mkdir, etc.

u Cambio del bit “setuid” para el usuario y del bit “setgid” para el grupo:

-r-x-—x-—x -r-s--x-—x

-r---—x-—x -r-S--x-—x

-r-x—-x--- -r-x-—s—--

chmod 4511 (ó chmod u+s)

chmod 4411 (ó chmod u+s)

chmod 2510 (ó chmod g+s)

Bit “setuid”

Bit “setgid”


SS OOIIIIIIII


Índice






n Procesos en Minix

n Procesos en Linux




*


SS OOIIIIIIIIEstados de un proceso

n Cuando un proceso se ejecuta pasa por distintintos estados

n Diagrama de transición entre estados:

Ejecución

Listo BloqueadoFin E/S o llegada evento

ExitEspera por E/S o

eventoA C

PU

Expuls

ión C

PU


SS OOIIIIIIIIEstados de un proceso

n Estados suspendidos:

Ejecución

Listo ysuspendido

Listo

Bloqueado ysuspendido

Bloqueado

Planificado

Tiempo consu

mido

Fin E/S o llegada evento

Exit

Fin E/S

Exp

ulsa

doal

disc

o

Exp

ulsa

doal

disc

o

Rec

upe r

ado

deld

isco

Entra alsistema

Mem

oria

Procesos por lotesen espera

Espera por E/S

o evento

Zona

de

inte

rcam

bio


SS OOIIIIIIII


Índice






n Procesos en Minix

n Procesos en Linux




*


SS OOIIIIIIIIFormación de un proceso

Mapa dememoria

Imagendel proceso

Tabla de procesos

BCPC

arg

ad

or

Objetoejecutable

Bibliotecasistema


SS OOIIIIIIII


Índice






n Procesos en Minix

n Procesos en Linux




*


SS OOIIIIIIIIConcepto de hilo de ejecución

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

u Ejecución secuencial.u Ejecución independiente.

n Planteamiento:

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

u Un programa podría incluir varias actividades concurrentes Õ Ejecución concurrente dentro de un proceso.



n ¿Qué es un hilo de ejecución?

u También llamado hebra, proceso ligero, flujo, subproceso o “thread”.u Programa en ejecución que comparte la imagen de memoria y otros

recursos del proceso con otros hilos.u Desde el punto de vista de programación: Función cuya ejecución se

puede lanzar en paralelo con otras.u Un proceso puede contener uno o más hilos.



n ¿Qué es un hilo de ejecución (cont.)?

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

Proceso

Hilo 2

PC2PC1

Pila 1

Pila2

Datos

Código

Otros recursos:-Ficheros abierto-Dispositivos E/S, etc.

Hilo 1



n Descriptor de un proceso y de un hilo:

. . .

. . .

Hilo 1 (principal)

Hilos

Zonas de memoria

Gestión de E/S

Otros datos

Estado, tiempo de CPU, registros de CPU, pila, etc.

Espacio de direcciones

Ficheros abiertos, dispositivos abiertos, etc.

Hilo 2

Hilo j

. . .



n Descriptor de un proceso y de un hilo:

u Todos los hilos de un proceso comparten el mismo entorno de ejecución (variables globales, espacio de direcciones, ficheros abiertos, etc.).

u Cada hilo tiene su propio juego de registros de CPU, pila, variables locales, etc.

u No existe protección entre hilos: un error en un hilo puede estropear la pila de otro.

u Para ordenar la forma en la que los hilos acceden a datos comunes hay que emplear mecanismos de sincronización.


SS OOIIIIIIIIEstados de un hilo y de un proceso

n Estado de un proceso con hilos:

u Combinación de los estados de sus hilos:

l Si hay un hilo en ejecución Õ Proceso en ejecución

l Si no hay hilos en ejecución pero sí preparados Õ Proceso preparado

l Si todos sus hilos bloqueados Õ Proceso bloqueado

Proceso

Hilo

Activo

Bloqueado por acceso a discoBloqueado por comunicación


SS OOIIIIIIIIParalelización usando hilos

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

n Mientras un hilo está bloqueado, otro podría ejecutarse

u Uso de llamadas al sistema bloqueantes por hilo

Procedimiento 2

Procedimiento 1

Esperaen E/S

P F

Procedimiento 1

Ejecuciónparalela

Ejecuciónserie

Esperaen E/S

P F

Procedimiento 2

Esperaen E/S

P F

Esperaen E/S

P F Procesamiento


SS OOIIIIIIIIServidor con múltiples hilos

n Hilos trabajadores:

u Pueden crearse a medida que se necesitan y destruirse al finalizar la tarea encomendada

u Pueden existir siempre y quedar libres al finalizar la tarea encomendadal Más eficiente (evita el trabajo de crear y destruir hilos)

Hilo distribuidor

Hilo trabajador

Peticiones

Proceso


SS OOIIIIIIII

n Ejemplo: Servidor secuencial de ficheros

AlgoritmoMientras no haya que terminar {

Esperar a que llegue una peticiónComprobar que la petición es correctaSi (los datos no están en la caché) {

Realizar operación de E/S bloqueante sobre disco}Enviar resultado

}

l Sencillol Prestaciones pobres: permanece bloqueado

Servidor con múltiples hilos

Caché para bloques accedidos recientemente


SS OOIIIIIIIIServidor con múltiples hilos

n Ejemplo (cont.): Servidor de ficheros con múltiples hilos

l Mayor complejidadl Buenas prestaciones

Algoritmo 1Mientras no haya que terminar {

Esperar a que llegue una peticiónEsperar trabajador libre}Enviar resultado

}

Algoritmo 2Mientras no haya que terminar {

Esperar trabajoComprobar que la petición es correctaSi (los datos no están en la caché) {

Realizar operación de E/Sbloqueante sobre disco

}Enviar resultadoAvisar que está libre

}

Hilo distribuidor Hilo trabajador


SS OOIIIIIIIIConcepto de multihilo

n Capacidad de un SO para mantener varios hilos de ejecución dentro de un mismo proceso.

Múltiples procesosMúltiples hilos/proceso

Ej: Windows 2000, Solaris, OS/2

Técnica Técnica multihilomultihilo

Un procesoMúltiples hilos/proceso

Ej: Java

Un procesoUn hilo/proceso

Ej: MS-DOS

Múltiples procesosUn hilo/proceso

Ej: Algunos UNIX

MonoMonoProceProceSadoSadoresres

Técnica Técnica monohilomonohilo

Proceso

Hilo

MultiMultiProceProcesadosadoresres


SS OOIIIIIIIIImplementación de hilos

n Dos categorías:

u Hilos a nivel de usuario

u Hilos a nivel de núcleo


SS OOIIIIIIIIHilos a nivel de usuario

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

n El núcleo no es consciente de la existencia de hilos.

n Es posible programar cualquier aplicación como multihilo.

Biblioteca de hilos

Modo supervisor

Modo usuario

P

Hilo a nivel de usuario

ProcesoP


SS OOIIIIIIIIHilos a nivel de usuario

n Ventajas frente a hilos a nivel de núcleo:

u No necesario acceder al núcleo para intercambio de hilos.u Algoritmos de planificación ad-hoc para cada aplicación.u Pueden ejecutarse en cualquier SO.

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

u Una llamada al sistema realizada por un hilo bloquea a todos los hilos del proceso.

u Una aplicación multihilo no puede aprovechar las ventajas del multiprocesamiento.

n Ejemplo:

u Pthreads de POSIX.


SS OOIIIIIIIIHilos a nivel de núcleo

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

n Es posible programar cualquier aplicación como multihilo.

Modo supervisor

Modo usuario

Proceso


P

Hilo a nivel de núcleo

P


SS OOIIIIIIIIHilos a nivel de núcleo

n Ventajas frente a hilos a nivel de usuario:

u El bloqueo de un hilo no supone (necesariamente) bloquear todo el proceso.

u Planificación de múltiples hilos de un proceso en múltiples procesadores.

u Las funciones del núcleo pueden ser multihilo.

n Desventajas frente a hilos a nivel de usuario:

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

n Ejemplos:

u Linux, Windows 2000, OS/2.


SS OOIIIIIIIIAproximaciones combinadas

n Ejemplo: Solaris

u Creación, sincronización y planificación de hilos de una aplicación en modo usuario.

u Planificación de múltiples hilos de un proceso en múltiples procesadores.

u El bloqueo de un hilo no supone (necesariamente) bloquear todo el proceso.


SS OOIIIIIIIIAproximaciones combinadas

n Ejemplo: Solaris (cont.)

Modo usuarioBiblioteca de hilos

Modo supervisor Proceso


P

Hilo a nivel de núcleo

P P


SS OOIIIIIIIIModelos multihilo

n Relación de:

u Muchos a uno.u Uno a uno.u Muchos a muchos.

DescripciónHNU:HNN Ejemplos

Pthreads POSIX

Windows 2000, OS/2

Solaris

M:1

1:1

M:NHilo a nivel de usuario (HNU)

Hilo a nivel de núcleo (HNN)



n Ventajas de utilizar múltiples hilos:

u La ejecución concurrente de hilos de un mismo proceso puede mejorar la eficiencia del sistema.

l Paralelismo dentro del proceso (en multiprocesadores).l Las operaciones bloqueantes no paralizan al proceso (completo).

u Mayor eficiencia que con múltiples procesos en:l Creación/eliminación de unidades de planificación.l Cambio de contexto.

u Una buena solución para sistemas cliente/servidor.

u Facilidad de implementación.


SS OOIIIIIIII


Índice






n Procesos en Minix3 Estados de un proceso3 Implementación del descriptor de proceso

*


SS OOIIIIIIIIProcesos en Minix

n Diagrama de transición entre estados:

u ready: Pone el proceso en alguna de las colas de procesos listos del planificador → Activa el proceso

u unready: Elimina el proceso de las colas de procesos listos → Suspendeel proceso

u pick_proc: Selecciona el proceso listo a ser ejecutado por la CPU →Planificador

u sched: Pone al final de la cola el proceso de usuario en ejecución pueséste ha agotado su quantum de CPU

ready

sched

En ejecuciónunreadypick_proc

BloqueadoListo



n 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 */



n 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];


SS OOIIIIIIII


Índice






n Procesos en Minix

n Procesos en Linux3 Estados de un proceso3 Implementación del descriptor de proceso3 Implementación de la tabla de procesos3 Implementación de la lista de procesos preparados

*


SS OOIIIIIIIIProcesos en Linux

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

n Bloqueo de un proceso:u Espera a que ocurra un cierto evento

u Proceso bloqueado e interrumplible:l Puede ser interrumpido por señalesl Puede desbloquearle:

Una interrupción HW Liberación de un recurso por el que esperaba Una señal

u Proceso bloqueado e ininterrumplible:l No acepta señalesl Puede desbloquearle:

Una interrupción HW Liberación de un recurso por el que esperaba



n Descriptor de un proceso:

u Estructura task_struct del fichero include/linux/sched.h

n 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 unaseñ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



n 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 */



n 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 porconsumir */

/* 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



n 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 */

hijo másjoven hijo hijo más

viejo

padre

p_pptr

p_osptr

p_ysptr

p_osptr

p_ysptr

p_pptr

p_pptrp_cptr



n 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 */



n 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?



n 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 delsegmento de datos */

unsigned long start_stack; /* Dirección del tope del segmentode pila de usuario */

...};



n 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*/

};



n Sistema de ficheros del proceso (cont.):

Tabla de inodosTabla de ficheros del sistema

Tabla de ficheros del proceso

0

1

2

3

4

5

6

1 READ. . .

1 WRITE

1 READ. . .

. . .

1 /etc/passwd

2 /usr/castano

. . .



n Lista de procesos preparados:u 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

Incluye el proceso en ejecución



n Lista de procesos del sistema:

u 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



n Tabla de procesos:

u Vector task del fichero kernel/sched.c

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

struct task_struct init_task;

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

u Vector task del fichero kernel/sched.c

#define for_each_task(p) \

for (p = &init_task ; (p = p->next_task) != &init_task ; )


SS OOIIIIIIII


Índice






n Procesos en Minix

n Procesos en Linux

n Procesos en Windows NT/20003 Objetos tipo proceso e hilo3 Estados de un hilo3 Implementación del procesos e hilos

*


SS OOIIIIIIIIProcesos en Windows NT/2000

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

u Los procesos NT se implementan como objetos y son accedidos mediante servicios de objetos

u Un proceso NT tiene asociados varios hilos que se ejecutan en su espacio de direccionamiento

u El gestor de procesos NT no mantiene ninguna relación entre los procesos que crea



n Objeto tipo proceso:

Identificativo de procesoObjeto de accesoPrioridad baseAfinidad del procesadorTiempo de ejecuciónPuertos de comunicaciónEstado de finalizaciónetc.

PROCESO

Tipo

del

ob

jeto

Atr

ibut

os

del o

bjet

oS

ervi

cios

de

l obj

eto

Crear procesoAbrir procesoPedir información del procesoAñadir información del procesoFinalizar procesoAsignar/liberar memoria virtualLeer/escribir memoria virtualetc.



n Objeto tipo proceso (cont.):Atributo DescripciónID 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



n Objeto tipo hilo:

Identificativo de hiloContextoPrioridad basePrioridad dinámicaAfinidad del procesadorTiempo de ejecuciónPuerto de terminaciónEstado de finalizaciónetc.

HILO

Tipo

del

ob

jeto

Atr

ibut

os

del o

bjet

oS

ervi

cios

de

l obj

eto

Crear hiloAbrir hiloPedir información del hiloAñadir información del hiloFinalizar hiloSuspender/continuar hiloGuardar/cargar contextoetc.



n 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



n Diagrama de transición entre estados (de un hilo):

Inicializado

Finalizado

Ejecución

Bloqueado

Alerta

ListoEvento

Expulsar

Reinicializar

Finalización

A CPU

Esperar evento

Exp

ulsa

r

Pla

nific

ador



n Algunos estados de un hilo:

u Alerta: Seleccionado como el siguiente hilo a ser ejecutado en un procesador dadoOperación (planificación) previa a la invocación de un cambio de contexto

u 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



n Implementación de procesos e hilos en Windows NT/2000:

Objetoproceso

Objetode aceeso

Descripción del espacio virtual de direccionamiento

Subproceso x

Fichero y

Sección z

Tabla de objetos

. . .

.

..


SS OOIIIIIIII


Índice






n Procesos en Minix

n Procesos en Linux


n Planificación de procesos e hilos*

3 Planificación en Minix

3 Planificación en Linux

3 Planificación en Windows NT/2000


SS OOIIIIIIIIEl planificador de Minix

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

n Se invoca al planificador (rutina pick_proc) cuando:

u Se bloquea un proceso (en ejecución) con SEND o RECEIVE

u Tras cada interrupción

u Tras la finalización del cuantum de CPU de un proceso de usuario

u Al finalizar un proceso

FCFSTAREAS

FCFSPROCESOS SERVIDOR

RRPROCESOS USUARIO-

+

PRIORIDAD



FCFSTAREAS

FCFSPROCESOS SERVIDOR

RRPROCESOS USUARIO-

+

PRIORIDAD

rdy_head[TASK_Q]

rdy_head[SERVER_Q]

rdy_head[USER_Q]

n Implementación del planificador:



n 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 */}

}


SS OOIIIIIIIIPlanificación en POSIX

n Cada política de planificación lleva asociado un rango con al menos 32 niveles de prioridad

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

n Políticas de planificación:

u FIFO (FCFS)u Round Robin (RR)u Otra


SS OOIIIIIIIIEl planificador de Linux

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

u Todo proceso del sistema tiene asociadasl una prioridadl una política de planificación, que puede ser:

FIFO (SCHED_FIFO) RR (SCHED_RR) Otra (SCHED_OTHER)

u 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)



n Prioridad y algoritmo de planificación de un proceso de Linux (cont.):

u Política SCHED_OTHER:l Favorece procesos interactivosl Prioridad dinámica = Prioridad_base + (Estimación_CPU_restante / 2)l Objetivo prioridad base: Dividir los procesos en bandas fijas de

prioridad



n Algoritmo de planificación:

u Algoritmo expulsivo con prioridades (selecciona el proceso con máxima prioridad)

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

u Un proceso FIFO abandona la CPU cuando:l Aparece otro proceso listo con mayor prioridadl El proceso finaliza

u Un proceso RR abandona la CPU cuando:l Aparece otro proceso listo con mayor prioridadl El proceso finalizal Acaba su quantum de CPU y otro proceso tiene igual prioridad (y es

la máxima)



n Función de planificación:

void schedule(void){

int c;struct task_struct * p, * prev, * next;

prev = current;

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

Deshabilitar interrupciones

Habilitar interrupciones



n 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




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




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

}


SS OOIIIIIIIIEl planificador de Windows NT/2000

n Prioridad de un hilo:

u Dentro del rango 0..31u Depende del tipo de trabajo que esté haciendou Una cola de hilos listos por cada posible nivel de prioridad

n Tipos de prioridad:

u Prioridades en tiempo realu Prioridades variables



n Prioridades en tiempo real:

u Prioridades más altas (rango 31..16)u Asignadas cuando el tiempo de respuesta del subproceso es crítico

(operaciones de comunicaciones, tareas de tiempo real, etc.)u La prioridad del hilo no cambia nuncau Política RR para los hilos de un nivel de prioridad dado



n Prioridades variables:

u Prioridades más bajas (rango 15..0)u Cola RR en cada nivel de prioridad

u Prioridad inicial del hilo:l Prioridad del proceso + Prioridad base del hilo (-2..+2)

u La prioridad del hilo puede variar durante su vidal No puede ser superior a 15 l No puede ser inferior a la prioridad iniciall El núcleo baja la prioridad (dinámica) de un hilo cada vez que finaliza

su quantum de CPU asignadol 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



n Prioridades variables:

u Ejemplo de relación entre prioridades

menordebajo normal

normalencima normal

mayor

0123456789

101112131415

Prioridad base del proceso

Prioridad inicial del

hilo

Prioridad dinámica del hilo

+2+1

-1-2

0



n Algoritmo de planificación de hilos:

u Esquema expulsivo con prioridades y colas multinivel realimentadas (selecciona el hilo con máxima prioridad de todas las colas)

NIVEL DE PRIORIDAD

31

.

.

.

.

.

.

.

.

.

16

15

14

0

.

.

.

.

.

.

Prio

ridad

es e

n tie

mpo

real

Prio

ridad

es

varia

bles


SS OOIIIIIIII


Índice






n Procesos en Minix

n Procesos en Linux



n Servicios POSIX para gestión de procesos e hilos*


SS OOIIIIIIIIServicios POSIX para gestión de hilos

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

Pthreads


SS OOIIIIIIIIServicios POSIX sobre atributos de hilos

n Creación de atributos:u Sintaxis:

int pthread_attr_init(pthread_attr_t *attr);

u Descripción:l Inicia un objeto atributo de tipo pthread_attr_t con las

propiedades que tendrán los hilos que se creen posteriormentel Los atributos permiten especificar: tamaño de pila, prioridad, política

de planificación, etc.l Existen diversas llamadas para modificar los atributos



n Destrucción de atributos:u Sintaxis:

int pthread_attr_destroy (pthread_attr_t *attr);

u Descripción:l Destruye el objeto atributo de tipo pthread_attr_t pasado como

argumento a la misma



n Establecimiento del estado de terminación:u Sintaxis:

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);

u Descripción:l 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


SS OOIIIIIIIIServicios POSIX sobre gestión de hilos

n Creación de hilos:u Sintaxis:

int pthread_create (pthread_t *thread,

const pthread_attr_t *attr, void *(*func)(void *),

void *arg);

u Descripción:l Crea un hilo con atributos attr que ejecuta func con argumentos arg

n Finalización de hilos:u Sintaxis:

int pthread_exit(void *value);

u Descripción:l Finaliza la ejecución de un hilo, indicando su estado de terminación



n Suspensión de hilos:u Sintaxis:

int pthread_join(pthread_t thid, void **value);

u Descripción:l Suspende la ejecución de un hilo hasta que termina el hilo con

identificador thid (no necesariamente un hilo hijo)l Deja el estado de terminación del hilo en la posición apuntada por value

l Sólo se puede solicitar este servicio sobre hilos no independientes

n Identificación de hilos:u Sintaxis:

pthread_t pthread_self(void);

u Descripción:l Devuelve el identificador del hilo que ejecuta la llamada



n Jerarquía de hilos:

Hilo 1

pthread_create

Hilo 4

pthread_exit

pthread_create

Hilo 2

pthread_create

Hilo 3

pthread_join

pthread_exit

No independiente

Hilo principal (main)



#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(){char *cadena1="Hola";char *cadena2="Adios";

pthread_t hilo1, hilo2;

pthread_create(&hilo1, NULL, hilo, (void *)cadena1);pthread_create(&hilo2, NULL, hilo, (void *)cadena2);

exit(0);}

n Ejemplo 1:

A partir de aquí, el hilo principal, hilo1 e hilo2 se ejecutan concurrentemente. Cualquiera puede acabar 1°, 2°o último



#include <pthread.h>#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);

}

n Ejemplo 2:¡Ojo a la exclución mutua!


SS OOIIIIIIIIServicios POSIX para gestión de procesos

#include <stdio.h>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);}

n Ejemplo 2: Código pseudo-equivalente con gestión de procesos pesados:

¿Por qué?



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

} }

n Ejemplo 3:



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

}

n Ejemplo 3 (cont.):

¿Funcionamiento correcto?


SS OOIIIIIIIIEjercicios

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



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)

doprintf (“%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);}




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



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



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



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



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

. . .

. . .Política planificación

Prioridad dinámicaPrioridad estática

Proceso init

. . .

. . .Proceso 1

FIFO2020

. . .

. . .Proceso 2

OTHER5075

. . .

. . .Proceso 3

RR0

25. . .

. . .Proceso 4

FIFO2525

. . .

. . .Proceso 5

RR2025

. . .

. . .Proceso 6

RR2525

. . .

. . .Proceso 7

OTHER2020

. . .

. . .Proceso 8

FIFO2525

counter

priority counter

rt_prio

rity

rt_prio

rity




1. El proceso 3 se mueve al final de la lista2. La función goodness proporciona las siguientes prioridades a los

procesos de la lista de procesos listos:

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

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



n 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).



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



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




Veámoslo con el siguiente ejemplo:

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.

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



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

so ii tema 2. procesos e hilos -...

Documents