Gestión de Procesos1 Horas 1INTRODUCCIÓN4 2PROCESOS Y THREADS10 3GESTIÓN DE MEMORIA8 4ENTRADA / SALIDA2 5SISTEMA DE FICHEROS6 sisOpeTemarioCurso: 15/16

Gestión de Procesos 1

Horas

1 INTRODUCCIÓN

4

2 PROCESOS Y THREADS

10

3 GESTIÓN DE MEMORIA

8

4 ENTRADA / SALIDA

2

5 SISTEMA DE FICHEROS

6

sisOpe TemarioCurso: 15/16


sisOpe 2. Procesos y Threads Curso: 15/16

• Introducción

• Procesos• Visión abstracta• Esbozo de implementación

• Threads (Procesos ligeros)

• Comunicación entre procesos• Condición de carrera• Exclusión mutua y región crítica• Implementación de la exclusión mutua• Paso de mensajes

• Planificación de procesos• Criterios• Políticas

• Sistemas multiprocesador


INTRODUCCIÓNInteresa tener máquinas que ejecuten varios procesos al mismo tiempo

18

T1

T2

T3

t

Aprovechar tiempos muertos E/S

Soluciones elegantes concurrentes

Más rapidez con más de una CPU

T1

T2

T3

t13

CPU1

CPU2Con multiprocesadores

también interesa multiplexar las CPU’s

pseudoparalelismo


PROCESOS (Visión abstracta: Recordar sus llamadas)

Dos relaciones típicas entre proceso Padre y proceso Hijo:

1. Procesos independientes: La “shell” crea un proceso para ejecutar un programa de usuario “ls”

ls.exe

shellPa. Debe cargarse el ejecutable

en memoria lsb. Dotarle de registros, pila, etc.

H

a. El código ya está en memoria

2. Procesos cooperantes: Un servidor Web crea un proceso para atender una petición de un cliente

web

P

b. Dotarle de registros, pila, etc.H Parecido a

Threads

¿fork + exec?

¿fork?



Proceso de arranque y grupos de procesos

P1

P2 P3

P4

P5

P6

P7init

id:rlevel:action:process

/etc/inittab

xinetd

/etc/rc5.d

/etc/rc.d/rc 5loginlogin

login as:Password:

bashpcarazo:........:/bin/bash

/etc/passwd

PC1>

grupo de procesos

RedRed

putty?

gdm

0 Halt

1 Monousuario

2 MultiSinRed

3 MultiConRed

5 X11

6 Reboot

rlevel




Esbozo de implementación¿Cómo es el ciclo de vida de un proceso?

CPUCreación

P1P2P3

P1

¿P1.read(disco, )?¿P2.sleep(5 )?

P2P3

P2

P3P4

¿P3 mucha CPU?Expulsión

P3 P4P3

¿P1 fin E/S?

P1

¿P4 read(cinta, )

P4

P3P1

¿P3 termina?

TerminaciónP1P2P4

¿Estados de un proceso?

• EnEjecución

• Preparado

• EnEspera o Bloqueado

Activo

Ejecu.

Prep. Espera


Diagrama de transición de estados de un Proceso

Preparado

EnEjecución

EnEspera

forkh

forkp

exit

exit

exit

wait

wait

wait sleep

sleep

F.R.

F.R.

F.R.

F.R.

¿forkp?

¿forkh?


El contexto de un proceso está distribuido en varias zonas

CPU

MP

MSec

S.O.

Esbozo de implementación en términos más informáticos

• Contexto de memoria (Código y Datos)MP/MSec• Bloque de control (descriptor) del Proceso MP (S.O.)• Contexto del procesador Reg/MP/MSec

Ejecutándose

Bloqueado

pila


Esbozo de implementación ( ¿Cuántos procesos? )

¿#Procesos ilimitado o un máximo predeterminado?

maxProcesos: constant:=100;

type idProceso is NATURAL range 0..maxProcesos;

Reservado

procesos : array[1..maxProcesos] of descriptorProceso;

1 2 3 4 97 98 99 10050

type descriptorProceso is record pid: ----------; --------------- end record;

584

ejecutandose : idProceso;

¿Correcto?


Esbozo de implementación ( ¿Cómo dar los PID’s? )

type descriptorProceso is record pid: idProceso; --------------- end record;

1 2 3 4 97 98 99 10050

1..100

¿Problemas?

• 99 procesos en el sistema

• Hago ps y veo un proceso mío (57)

• Me dispongo a kill –9 57

• Mi proceso termina antes del kill y se crea otro proceso con el código 57

¡ Mato a otro proceso !

Mejor espaciar más los códigos

pid: NATURAL; 1..65535...

Algo más complejodar PID’s

0 Descriptor libre

¿ejecutandose?


Esbozo de implementación ( ¿Estados y su gestión? )

type unEstado is (ejecutandose, preparado,espLapso, espFinHijo, zombie);


Esbozo de implementación ( ¿Estados y su gestión? )

type unEstado is (ejecutandose, preparado,espLapso, espFinHijo, zombie);

type descriptorProceso is record pid: NATURAL; estado: unEstado; end record;

1 2 3 4 97 98 99 10050

CPU queda libre. ¿A qué Pi se la doy?

• Recorro procesos buscando uno que esté preparado Lento e injusto

• Si decido elegir al Pi que lleva más tiempo preparado, lo mejor cola FIFO

type unaCola is record primero: idProceso := 0; ultimo: idProceso:= 0;end record;

preparados: unaCola;

sig: IdProceso;

ejecutandose: idProceso;


Esbozo de implementación ( ¿Procesos bloqueados? )

espLapso => Muy parecido a preparados, sólo que es necesario indicar cuándo despertarles o cuánto falta para despertarles, ...

1 2 3 4 97 98 99 10050

type descriptorProceso is record pid: NATURAL; estado: unEstado; sig: idProceso; lapso: NATURAL; end record;

espLapso : unaCola;

105 25

• El campo sig me sigue sirviendo para encadenar

• Otras formas de implementarlo:

55 15

4 5097


Esbozo de implementación ( ¿Procesos bloqueados? )espFinHijo => El fin de un hijo sólo puede estar esperándolo su Padre.

Puede no ser necesaria una cola.type descriptorProceso is record pid: NATURAL; padre: idProceso; estado: unEstado; sig: idProceso; lapso: NATURAL; end record;

• El Padre (P) hace wait (H):

-- Localizar H en procesos => hif h.estado = zombie then

Liberar recursos del Hijo ycontinuar al Padre

else -- hijo vivop.estado:=espFinHijo; p.sig:=h;liberar CPU;

• Un Hijo(H) termina exit:

If (p.estado = espFinHijo) & (p.sig = h) thenliberar recursos Hijo y continuar Padre

elseh.estado := zombie y liberar CPU


Esbozo de implementación ( Concluyendo )maxProcesos : constant := 100;type idProceso is NATURAL range 0..maxProcesos;type unEstado is (ejecutandose, preparado,

espLapso, espFinHijo, zombie);type descriptorProceso is record pid: NATURAL; padre: idProceso; estado: unEstado; sig: idProceso; lapso: NATURAL; SP: address; memoria: ----------; ficheros: ----------; tiempos: ----------; end record;

type unaCola isrecord primero: idProceso := 0; ultimo: idProceso := 0;end record;

procesos : array [1..maxProcesos] ofdescriptorProceso;

ejecutandose: idProceso;preparados, espLapso: unaCola;

¿ fork y exec ?


Campos en una entrada a la tabla de procesos

Esbozo de implementación ( Otro ejemplo )


Esbozo de implementación ( El Cambio de Contexto )

Causas?

• Llamada al Sistema• Fin de Proceso

Bien/Mal

• Interrupción

Trap

(E/S, F.R.)

Mecanismo similar

Supongamos como causa “Fin de Rodaja”

ejecu-tándose Pi

Hw

(1)

(1) Reconocimiento de la interrupción

S.O. Pj

Ens.

(2)

(2) Salvar reg (Pi) y conmutar de pila

C/Modula/Ada

(3)

(3) 1 Recorrer dormitorio2 Elegir siguiente proceso

Ens.

(4)

(4) Recuperar reg (Pj) y cederle control

Planificador

Dispatcher

¿No hay procesos

preparados?


Vector de Interrupciones

S.O.

Esbozo de implementación ( El Cambio de Contexto )

--------------------sleep(10)--------------------exit(0)

------------------------------------------------------------------------------------

TRAP #0

-----------------------------------

INT 3

----------divu d5,d0---------- -------

----------------------------

DIV 0

Se salva el SR y PC

--------------------------------------------------------

Cambio de contexto


Threads ( Visión abstracta )Modelo de procesos más común Espacios de direcciones disjuntos

RegistrosCódigo

Datos, PilaFicheros

Pi

RegistrosCódigo

Datos, PilaFicheros

Pj

fork execls.exe

Facilita protección PiPj, pero:

• Creación laboriosa

• Cambio de contexto pesado

(procesador + entorno) TLB’s, cachés, ...

• Comunicación vía mensajes

más seguro pero más lento

¿Y si los procesos son cooperantes?

• Objetivo común

Colaboración vs agresión

Protección más laxa

• Pueden desear mantener datos comunes con los menores costes de tiempo


BD utilidades

Threads ( Visión abstracta )Procesos Ligeros Espacios de direcciones no disjuntos

RegistrosPila

RegistrosPila

Código, DatosFicheros

Ti Tj Servidor de localización de utilidades

C1C2

Cn

Sconsultaalta

consulta

petición

respuesta

peticiónpetición

¡ Muy eficaz con multiprocesadores !

• Soportados de dos formas:

• En el espacio del S.O.

• En el espacio del UsuarioBiblioteca


Threads ( “Linux” )

int __clone (int (*fn) (void *arg), void *child_stack, int flags, void *arg)

Como fork sólo que crea un Thread “Específico de Linux”

Thread soportado como tal por el S.O. (no portable)

Biblioteca pthread (API POSIX 1003.1c)

int pthread_create (pthread_t * thread, atributos, funcion, argumentos)

pthread_t pthread_self (void)

int pthread_exit (void *estado)

int pthread_join (pthread_t thread, void **estado)

...................................................

...................................................

¿ fork + threads ?


Threads ( Ejemplos de uso: tonto.c )#include <pthread.h>

#include <stdio.h>

int main (int argc, char *argv[]){

pthread_t tA, tB;

int datoA=0; datoB=0;

pthread_create(&tA, NULL, A, NULL);

pthread_create(&tB, NULL, B, NULL);

pthread_join (tA, NULL);

pthread_join (tB, NULL);

exit (0);

}

void *B (void *basura) {

datoB = 2000;

sleep (5);

printf (“datoA=%d\n”, datoA);

pthread_exit (NULL);

}

void *A (void *basura) {

datoA = 1000;

sleep (5);

printf (“datoB=%d\n”, datoB);

pthread_exit (NULL);

}

datoC=0;

int datoC; int datoC;

?

Threads ( Ejemplos de uso: cuentaPar.c )

• cuentaPar.c: Número de apariciones de un número en un vector

6 2 0 7 4 9 3 4 9 8 0 6 7 9 6 0 6 7 9 8 6 2 5 2 6 4 7 9 3 5 2 1 7 3 2 6 6 4 4 0

const N = 40; objetivo = 6; numCPUs = 4;var vector array[1..N] of integer;

¿ Algoritmo paralelo ?

T0 T1 T2 T3

1 3 2 2

+8


int longRodaja, numVecesLocal[MAX_ESCLAVOS], *vector;

void *esclavo (void *parametro) { ..... }

int main (int argc, char *argv[]) { int i, numVeces, cardinalidad = atoi (argv[1]); int numEsclavos = atoi (argv[2]); pthread_t pids[MAX_ESCLAVOS];

// Pedir memoria e inicializar vector

// Crear esclavos y esperar a que terminen su trabajo for (i = 0; i < numEsclavos; i++) pthread_create (&pids[i], NULL, esclavo, (void *) i); for (i = 0; i < numEsclavos; i++) pthread_join (pids[i], NULL);

// Sumar los valores de todos e informar del resultado numVeces = numVecesLocal[0]; for (i = 1; i < numEsclavos; i++) numVeces = numVeces + numVecesLocal[i]; printf (“Veces que aparece = %d\n”, numVeces);}

%cuentaPar 1000000 4


25Gestión de Procesos

// Variables globalesint longRodaja, numVecesLocal[MAX_ESCLAVOS], *vector;

void *esclavo (void *parametro) { int yo, inicio, fin, i, j, numVeces;

yo = (int) parametro; inicio = yo * longRodaja; fin = inicio + longRodaja;

// Buscar en mi parte del vector numVeces = 0; for (i = inicio, i < fin; i++) if (vector[i] == NUM_BUSCADO) numVeces++; numVecesLocal[yo] = numVeces; pthread_exit (NULL);}



5 1,286 4,26 0,85

6 1,127 4,86 0,81

7 1,113 4,92 0,70

8 0,998 5,49 0,69

cuentaPar 400.000.000 1..8 // Recorriéndolo diez veces

2 Xeon E5520 Quad2,26GHz • 8ML3 • 12GB • 500GB



Esclavos Tiempo Aceleración Eficiencia

1 5,480

2 2,721 2,01 1,01

4 1,408 3,89 0,97

An = T1 / Tn En = An / n

• sortPar.c: Ordenar un vector en memoria

3 8 15 2 4 1 7 10 6 14 13 5 11 9 12 16

T0 T1 T2 T3

2 3 8 15 1 4 7 10 5 6 13 14 9 11 12 16

ordenar

1 2 3 4 7 8 10 15 5 6 9 11 12 13 14 16

T0 T2mezclar

T0

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

mezclar

Threads ( Ejemplos de uso: sortPar.c )


• sortPar.c: Ordenar un vector en memoria [Refinamiento]

A B C D

E F

G

0 1 2 3

0 2

0

esclavo (yo: integer);

ordenarRodaja(yo); case yo of 0: mezclar(A,B,E); mezclar(E,F,G); 1: ; 2: mezclar(C,D,F); 3: ; end;

?

1. La mezcla es destructiva => vector auxiliar

Va

Va

Vb

Va

2 Mezclar requiere haber ordenado … => semáforos



• sem_init

• sem_wait

• sem_post

#define MAX_ENTERO 10000#define MAX_ESCLAVOS 4 // Solo funciona con 4 esclavos

//-------------- VARIABLES GLOBALES ------------------------------- int cardinalidad, longRodaja; int *vector, *vectorBis; sem_t S1a0, S3a2, S2a0;

void imprimir (int *vector) { int i;

printf ("Contenido del vector\n"); printf ("====================\n"); for (i=0; i<cardinalidad; i++) { printf ("%6d ", vector[i]); if ((i%10) == 0) printf ("\n"); } printf ("\n");}

void mezclar (int i, int longRodaja, int *vOrg, int *vDst) { int iDst, iTope, j, jTope;

iTope = i + longRodaja; j = iTope; jTope = j + longRodaja; for (iDst = i; iDst < jTope; iDst++) { if (i == iTope ) vDst[iDst] = vOrg[j++]; else if (j == jTope ) vDst[iDst] = vOrg[i++]; else if (vOrg[i] < vOrg[j]) vDst[iDst] = vOrg[i++]; else vDst[iDst] = vOrg[j++]; }}



void *esclavo(void *parametro) { int yo, inicio, fin, i, j, imenor, menor; int unCuarto, unMedio;

yo = (int) parametro; inicio = yo * longRodaja; fin = inicio + longRodaja; unMedio = cardinalidad / 2; unCuarto = cardinalidad / 4;

// Ordenar por insercion directa for (i = inicio; i < fin; i++) { imenor = i; menor = vector[i]; for (j = i; j < fin; j++) if (vector[j] < menor) { imenor = j; menor = vector[j]; } vector[imenor] = vector[i]; vector[i] = menor; }

// Fase de mezclas. Solo valida para 4 esclavos switch (yo) { case 0: sem_wait (&S1a0); mezclar(0, unCuarto, vector, vectorBis); sem_wait (&S2a0); mezclar(0, unMedio, vectorBis, vector); break; case 1: sem_post (&S1a0); break; case 2: sem_wait (&S3a2); mezclar(unMedio, unCuarto, vector, vectorBis); sem_post (&S2a0); break; case 3: sem_post (&S3a2); break; default: printf ("Error\n"); break; } pthread_exit(NULL);}



int main( int argc, char *argv[] ) { int i, numEsclavos; pthread_t pids[MAX_ESCLAVOS];

cardinalidad = atoi(argv[1]); numEsclavos = MAX_ESCLAVOS; longRodaja = cardinalidad / numEsclavos;

// Pedir memoria e inicializar el vector vector = malloc(cardinalidad * sizeof(int)); vectorBis = malloc(cardinalidad * sizeof(int)); for (i=0; i<cardinalidad; i++) vector[i] = random() % MAX_ENTERO; imprimir(vector);

// Inicializar semaforos para sincronizar sem_init (&S1a0, 0, 0); sem_init (&S3a2, 0, 0); sem_init (&S2a0, 0, 0);

// Crear esclavos y esperar a que terminen su trabajo for (i=0; i<numEsclavos; i++) pthread_create (&pids[i], NULL, esclavo, (void *) i); for (i=0; i<numEsclavos; i++) pthread_join (pids[i], NULL);

imprimir(vector); return (0);}

sort 200000 => 8:350sortPar 200000 => 2:100




pthread_create pthread_join

pthread_exit pthread_self

Threads ( En el espacio de usuario )

• El S.O. no los soporta

• Cambio contexto rápido

• Distintos planificadores

• read, … ¡ Bloqueantes !

• Falta de página

• ¡Planificación expulsora!


Threads ( En el espacio del S.O. )

?


Comunicación entre ProcesosLos procesos cooperantes necesitan mecanismos para sincronizarse y comunicarse información de forma segura

Sincronización Ordenación temporal de la ejecución de procesos

A antes que B

Canal de Panamá Tortilla de patatas

Batir Pelar PelarHuevos Cebollas Patatas

Mezclar, Añadir Sal y Freir

Comunicación Paso de información entre tareas

Síncrona o AsíncronaFiltros Unix:

who | wc | sed -e ‘s/ [ ]*/:/g’ | cut -d: -f2


Condiciones de CarreraLa falta de sincronismo entre procesos cooperantes da problemas

• Canal de Panamá Barco encallado

• Tortilla de Patatas No hay quien se la coma

• Uso de datos / recursos comunes Inconsistencia

¡Que buen negocio!

¡Me tangan!


Condiciones de Carrera (Modelización con threads)

Ingreso de Taxista 1 = 80729Ingreso de Taxista 2 = 80618Total recaudacion = 161096

+ 161347

int cuenta;

void *taxista(void *parametro) { ..... }

int main( int argc, char *argv[] ) { int i, numEsclavos; pthread_t pids[MAX_ESCLAVOS];

numEsclavos = atoi(argv[1]); cuenta = 0; // Crear esclavos y esperar a que terminen su trabajo for (i=0; i<numEsclavos; i++) pthread_create (&pids[i], NULL, taxista, (void *) i); for (i=0; i<numEsclavos; i++) pthread_join (pids[i], NULL);

printf ("Total recaudacion = %d\n", cuenta); return (0);}


Ingreso

Condiciones de Carrera (Modelización con threads)void *taxista (void *parametro) {

// Variables

recaudacion = 0; mio = 0; do { espera = random() % MAX_ESPERA; for (i=1; i<espera; i++); importe := random (maxImporte); mio := mio + (importe / RATIO_TAXISTA); cuenta := cuenta + importe – (importe / RATIO_TAXISTA); recaudacion := recaudacion + importe; } while (mio < SUELDO_DIA); printf (“Ingreso de Taxista %d = %d\n”, yo, recaudacion – mio); pthread_exit (NULL);}

Hacer Carrera

Buscar Cliente


Condiciones de Carrera (Modelización con threads)

Threads pc1:4Cores pc9:8Cores

2

4

8

16

32

Fallos x 1.000

7

64

230

533

830

207

926

1.000

1.000

1.000


3: cuenta := cuenta + importe

Condiciones de Carrera (El problema)

3.1: PUSH importe

3.2: PUSH cuenta

3.3: ADDP

3.4: POP cuenta

3.1, 3.2T1

T2

5.000cuenta

10.000T1.importe

3.35.00010.000

T1.SP

3.1, 3.2

1.500T2.importe

3.35.0001.500

T2.SP

3.3, 3.4

15.000

15.000cuenta

3.3, 3.4

6.500cuenta

6.500¿problema?


Exclusión mutua y Región crítica (La solución)

RC

RC

Aquí comomáximo un Pi

ExclusiónMutua

Integridad Datos

Comunes

Aquí cero,uno o más Pi

Los Pi indicarán cuándo EntranEnRC y cuándo SalenDeRC


Exclusión mutua y Región crítica (La solución)

EntrarEnRC;

cuenta := cuenta + importe – (importe div ratioTaxista);SalirDeRC;

REQUISITOS

• En una misma Región Crítica no más de un proceso

• Sin supuestos: #µP, #Pi, velocidades relativas, .....

• Ningún Pi fuera de su Región Crítica bloqueará a otros Pj

• Decisión de quién entra a una Región Crítica en un tiempo finito


Implementación de la Exclusión Mutua

Mecanismos:

• Inhibición de interrupciones • Semáforos

• Cerrojos (espera activa) • Monitores

Hw Sw

Lenguaje

S.O.

Inhibición de interrupciones

TaxistasInhibirInterrupciones

cuenta := cuenta + importePermitirInterrupciones

RC muy corta o puedenperderse interrupciones

Exclusión total vs parcial

DirecciónGeneralDeTráficorepeat

aguardarAgazapados y ¡foto!InhibirInterrupciones

numeroMultas++PermitirInterrupciones

until cubiertoCupo

Sólo válido en monoprocesador Peligroso en manos del usuario Útil dentro del propio S.O.


Implementación de la Exclusión Mutua ( Cerrojos )

Una variable “cerrojo” por cada RC distinta que indica Libre/Ocupada

TaxistasEntrar (RCTaxistas)

cuenta := cuenta + importeSalir (RCTaxistas)

Guardia CivilEntrar (RCDGT)

numeroMultas++Salir (RCDGT)

while RCT = ocupada do null;RCT := ocupada

cuenta := cuenta + importe;

RCT := libre

entrar tst.b RCTbnz entrarmove.b#$FF,RCTpushimportepush cuentaaddppop cuenta

salir move.b#$00,RCT

RCT dc.b 0

¡ No funciona !


Implementación de la Exclusión Mutua ( El cerrojo falla )

T1

T2

00RCT

--------------------------------

entrar tst.b

RCT

--------------------------------tst.b RCTbnz entrarmove.b #$FF,RCT--------------------------------

T1.SRZ

1

FFRCT

T2 dentro RCT

bnz entrarmove.b #$FF,RCT----------------------------------------------------------------

FFRCT

¡¡ T1 también dentro RCT !!


Implementación de la Exclusión Mutua ( Un cerrojo seguro? )

El Hw ayuda con una instrucción atómica que consulta y cambia valor

tas.b cerrojo, valortst.b cerrojo

move.b valor,cerrojo

Algoritmos: Dekker, Dijkstra, Knuth, Peterson, .......

entrar tas.bRCT,#$FFbnzentrarpushimportepushcuentaaddppopcuenta

salir move.b#$00,RCT

RCT dc.b 0

F.R. ¿Habrá problemas?

No funciona en multiprocesador ya que TAS es ininterrumpible dentro de un procesador, pero supone dos accesos al bus:

1 Lectura del cerrojo

2 Modificación del cerrojo

¡SI!


Implementación de la Exclusión Mutua ( Un cerrojo seguro! )

T1

T2

00RCT

--------------------------------tas.b RCT,#$FF

--------------------------------tas.b RCT,#$FFbnz entrar

T1.SRZ

1

FFRCT

FFRCT

bnz entrar----------------------------------------------------T1 en RCT

FFRCT

T2 no puede

entrar en RC

mientras está T1

tas.b RCT,#$FFbnz entrar


Implementación de la Exclusión Mutua ( TAS todavía falla! )

TAS PedirBus, Leer, PedirBus, Escribir

P1 T1 PB, L1, PB, E1P2 T2 PB, L2, PB, E2

???

P1 P2

RCT

L1, E1, L2, E2

T1 T2

L2, E2, L1, E1

T2 T1

L1, L2, E1, E2

T1 T2

tas.b RCT,#$FFbnz entrar

PHtasl.b RCT,#$FFbnz entrar------------------------------------------

¡ Todavía dos problemas !• Espera Activa• Inversión de prioridadesPL

deadLock ¿ Qué hacer ?

TASL “TAS with Lock” BusLock, Leer, Escribir, BusRelease

( El Hw nos ayuda )


Implementación de la Exclusión Mutua ( RC POSIX )

int pthread_mutex_lock (pthread_mutex_t *regionCritica)

int pthread_mutex_unlock (pthread_mutex_t *regionCritica)

¿Posible implementación (sin espera activa)?

type pthread_mutext_t is

record

libre : BOOLEAN;

cola : unaCola;

end record;

FRCT Pi Pj

lock (RCT):

inhibir interrupciones

salvarEstado(ejecutandose)

if RCT.libre

then RCT.libre = FALSE

else meter (ejecutandose, RCT);

ejecutandose = planificar();

recuperarEstado(ejecutandose)

rte /*Se habilitan interrupciones*/

Multiprocesador

?tasl¡ Ojo !


Implementación de la Exclusión Mutua ( Semáforos )

Soportado por el S.O. garantiza exclusión mutua sin espera activa

type Semaforos is private;

Inicializar (S: Semaforos; Valor: NATURAL);

Bajar (S); -- Puede bloquear al proceso (Si Valor = 0)

Subir (S); -- Puede desbloquear a UN proceso

Operaciones

Atómicas

Dar soporte a RC con semáforos es fácil:

Inicializar (S_RCT, 1) Inicializar (S_RCGC, 1)

--------------- ---------------Bajar (S_RCT) Bajar (S_RCGC)

Cuenta := Cuenta + Importe numeroMultas++Subir (S_RCT) Subir (S_RCGC)--------------- ---------------



Precisando la semántica:

P.Bajar (S) IF Valor(S) > 0 THENValor (P.Bajar(S)) = Valor(S) – 1

ELSEP deja UCP y se bloquea esperando P’.Subir(S)

P.Subir(S) IF Hay_algun_Pi_esperando_en (S) THENSacar a uno de ellos de espera

INDETERMINISMOProceso continuadoProceso que coge UCP

JUSTICIAELSE

Valor (P.Subir(S)) = Valor (S) + 1



private type Semaforos is record

valor : NATURAL;

cola : unaCola;

end record;

procedure Inicializar (S : out Semaforos;

valor : NATURAL) is

begin

S.valor := valor;

end Inicializar;

Esbozo de implementación:

0S Pi PkPj

¿Dónde están los semáforos?

Hacen falta operaciones del estilo: crear, conectarse, destruir

Exclusión mutua, Salvado estado Pi

Dispatcher



procedure Bajar (S: in out Semaforos) is begin

if S.valor = 0 then

encolar (ejecutandose, S.cola);

planificar;

else S.valor := S.valor - 1; endif;

end Bajar;

procedure Subir (S: in out Semaforos) is begin

if S.cola.primero /= 0 then

encolar (sacarProceso(S.cola), preparados);

planificar;

else S.valor := S.valor + 1; endif;

end Subir;


Implementación de la Exclusión Mutua ( Semáforos POSIX )

int sem_init (sem_t *S, int global, unsigned int valor)

int sem_wait (sem_t *S)

int sem_post (sem_t *S)

int sem_destroy (sem_t *S)


Paso de mensajes

Debilidades del Sincronismo + Memoria Común:

• Primitivas de bajo nivel (Inhibir Interrupciones, TASL, Semáforos)

• Inviable en sistemas débilmente acoplados sin memoria común

Solución: Envío y recepción de mensajes

Porg Pdst

Enviar (Pdst, msj) Recibir (Porg, msj)

---------------

Escribe

11---------------

--------------- 11

Lee

Primera aproximación a la sintaxis:void enviar ( int Pdestino, void recibir ( int Porigen,

char * msj ); char * msj );

¿Puede fallar enviar/recibir?

?

?int int

Paso de mensajes ( Ejemplos de uso: cuentaParMsj.c )

• ¿Cómo podría ser cuentaPar.c si no hay memoria común?

1 3 2 2

6 2 0 … 0 6 7 … 6 2 5 … 2 1 7 …

+8

esclavo1 esclavo2 esclavo3 esclavo4

maestro6 2 0 … 0 6 7 … 6 2 5 … 2 1 7 …

• El vector lo tiene un proceso “maestro”

• El maestro: reparte “envía” trabajo a los “esclavos” y

recoge “recibe” resultados

6 2 0 … 0 6 7 … 6 2 5 … 2 1 7 …

13 2 2



Paso de mensajes ( Ejemplos de uso: cuentaParMsj.c )

#define longRodaja (N/4)int vector[N], iRodaja;int veces, vecesLocal;

// Repartir trabajo iRodaja = 0; for e in 1..4 { enviar (e, &vector[iRodaja], longRodaja); iRodaja += longRodaja; }

// Recoger resultados veces = 0; for e in 1..4 { recibir (e, &vecesLocal, 1); veces += vecesLocal; }

#define longRodaja (N/4)

int rodaja[longRodaja];int veces;

recibir (0, rodaja, longRodaja); veces = contarEn (rodaja); enviar (0, &veces, 1);

maestro

esclavo


Paso de mensajes (muchas semánticas)

---------------rec (Po, msj)---------------

---------------env (Pd, msj)---------------

Pd ¿Bloqueo?

El bloqueo dependerá de la | de mensajes msj Se le entrega a Pd y continua

msj Se bloquea a Pd hasta

No siempreTiempo Real

Tolerancia a Fallos

• Bloquear

• Bloquear un máximo

• No Bloquear

int recibir ( int Porg, char * msj,int TmaxEsp)

70

?

?Po

• ¿Bloqueo?

• ¿Recibió Pd?

Po

Independencia del enlace de

comunicación


Paso de mensajes (Cuestiones de Diseño)

• Mensajes de longitud fija vs variable

• Capacidad de almacenamiento 0 ..

• Envío por copia vs referencia

• Comunicación Directa vs Indirecta

Pi B PjPi Pj

Simétrica vs Asimétrica Unidireccional vs Bidireccional


Paso de mensajes (Mensajes de longitud fija vs variable)

• Longitud Fija

El S.O. siempre envía

el total

La aplicación distingue

distintos msj.

Simplifica la gestión de la capacidad de almacenamiento del canal

• Longitud Variable

El S.O. envía lo que diga la

aplicación

¿Cómo?

110 Mensaje de 110 bytes

En el propio mensaje

enviar (Pdest, msj, 110)

En la llamada

61

Paso de mensajes (Mensajes de longitud fija vs variable)

MINIX 3

typedef struct {

int m_source;

int m_type;

union {

mess_1 m_m1;

mess_2 m_m2;

mess_3 m_m3;

mess_4 m_m4;

mess_5 m_m5;

mess_7 m_m7;

mess_8 m_m8;

} m_u;

} message;

m_source

m_type

m1_i1

m1_i2

m1_i3

m1_p1

m1_p2

m1_p3

m_source

m_type

m2_i1

m2_i2

m2_i3

m2_l1

m2_l2

m2_p1

m_source

m_type

m3_i1

m3_i2

m3_p1

m3_ca1

m_source

m_type

m4_i1

m4_i2

m4_i3

m4_i4

m4_i5

Práctica 4: Nueva llamada SO

Proceso70.if (proceso_vivo(84)

705784

# Llamada 57


Paso de mensajes (Capacidad de almacenamiento 0..)

Ilimitada ()

Po Pd

Po Pd¡Nunca Bloqueo!

Limitada (8)

Po Pd

Po PdHueco Sin Bloqueo

¡No hay Hueco!• Bloqueo

• Sin BloqueoEstado = Lleno

Comunicación Asíncrona

Nula (0)

Po Pd¡Siempre Bloqueo!

Po PdEspera a Pd.recibir

Po PdCita “Rendez-vous”

Po Pd

Comunicación Síncrona

Po sabe que Pd recibió

¿Y aquí?


Po Pd

Paso de mensajes (Envío por copia vs referencia)

Escribir---------------env (Pd, msj)

1

rec (Po, msj)

2

¡ 2 copias extra por cada envío/recepción !

Leer---------------

Envío por referencia

Po Pd

pedirBufferEscribir---------------env (Pd, msj) rec (Po, msj)

Leer---------------liberarBuffer

• Complejidad pedir/liberar Buffer

• ¿Y si no hay memoria común?

• ¿Seguridad?


Paso de mensajes (Comunicación Directa)

Indicación explícita• A qué proceso se desea enviar

• De qué proceso se desea recibir

Cliente Servidor¿15.731 es primo?

SÍ

repeat repeat

read (msjp.num); recibir ( Pc, &msjp);

enviar (Ps, &msjp); enviar ( Pc,

recibir (Ps, &msjr); respuesta(msjp))

imprimir (msjr.esPrimo) forever

forever

Simétrica

Simétrica


Paso de mensajes (Comunicación Directa “Características”)

• Creación automática del enlace Po Pd

• Necesidad de conocer los Pid’s de los procesos

• De Pi a Pj SÓLO un enlace en cada sentido

Cliente ServidoresPrimo?

Hora?Cliente Servidor?

15.7310

1

Tipo de mensaje

¿Todo resuelto?

Cliente ServidorPPPPPPPH

• Un enlace asocia SÓLO a dos procesos


Paso de mensajes (Un enlace asocia SÓLO a dos procesos)

C1

C2S

C1

C2S

repeat

if recibir (PC1, &msjp ) then

enviar (PC1, respuesta (msjp));

elsif recibir (PC2, &msjp ) then

enviar (PC2, respuesta (msjp));

forever

Servidor

• Inanición

• Espera Activa

, 1

, 1Mitigada?

• 50 Clientes????

! Demasiadas pegas ¡


Paso de mensajes (Comunicación Directa Asimétrica)Mejor admitir un recibir de cualquier proceso (no uno concreto)

C1

C2S

int recibir (char * msj)

Pid del proceso remitente

int recibir (int * remitente, char * msj)

equivalentes

repeat

remitente := recibir (&msjp);

enviar (remitente, respuesta (msjp));

forever

Servidor• ¿Más de un servidor?

int enviar (char * msj)

Pid del proceso que recibió???

CS1

S2


Paso de mensajes (Comunicación Indirecta)

bPetiPC PS

1 1

bPetiPC

PS1

PSm1 M

bPeti

PC1

PCn

PS1

PSmN M

¿Quién recibe?• Indeterminismo• Justicia• Integridad

bPeti

PC1

PCn

PS

N 1

¿De quiénrecibí?

PCn

enviar (buzon, msj) recibir (buzon, msj)

int recibir (buzon, msj)

PCn


Paso de mensajes (Comunicación Indirecta)Los enlaces pueden ser Unidireccionales o Bidireccionales

PC PS

¿ Problemas ?

PC1PS

PC2 ¿ Y aquí ?

Lo normal Unidireccionales:

bPeti

PCPS1

PS2bResp

¿ Código del Cliente y de los Servidores ?

Lo más general:

B1

P2P4

P5B2P3

P1

• Varios Procesos

• Varios Buzones

• Todo dinámico


Paso de mensajes (Comunicación Indirecta)

type Buzones is private;

function Crear (nombreB: Nombres ) return Buzones;

function Conectarse (nombreB: Nombres) return Buzones;

procedure Enviar (b: in out Buzones; msj: Mensajes);

procedure Recibir (b: in out Buzones; msj: out Mensajes);

procedure Destruir (b: in out Buzones);

Un modelo: Capacidad

*

* Propietario* Excepción buzonInexistente, ...

¡ Problemática Destrucción !• Mensajes en el buzón

• Procesos bloqueados

• Referencias a buzones destruidos

mqd_t mq_open (const char *name, int oflag, …)

int mq_send (mqd_t mqid, const char *msgptr, size_t msgsz, unsigned msgprio)

ssize_t mq_receive (mqd_t msid, char *msgp, size_t msgsz, unsigne *msgprio)

int mq_close (mqd_t mqid)

POSIX


Planificación de Procesos ( Criterios )Planificar Elegir el siguiente Pi a ejecutar

• JUSTICIA

• EFICIENCIA

• RENDIMIENTO

• MINIMIZAR TIEMPOS

Criterios

Carga

Sin CPU

Ejecutándose

Pi

Tiempo de

Retorno

CPU

Tiempo útil

Tiempo inútil

Tiempo de Espera¿Tiempo de Respuesta?

Pi

<cr>

Criterios difícilmente alcanzables:

Favorecer Pi Perjudicar Pj


Planificación de Procesos ( PCPU vs PE/S )

PCPU

PE/S

Periodos largos de CPUPeriodos cortos de CPU ?

¿Cómo reconocerlos?

Abandona voluntariamente la UCP


Sistemas Batch• No expulsores o expulsores con un quantum grande• Reducen cambios de contexto y mejoran el rendimiento

• Por niveles, Primero en llegar primero en servir FCFS, Más corto el siguiente SJF, Tiempo restante menor SRTN

Sistemas interactivos• Expulsores: evita la monopolización de la CPU

• Round-Robin, prioridades, múltiples colas, Más corto el siguiente SPN (envejecimiento)

Sistemas de tiempo real• Monotónico en frecuencia• Deadline más próximo el siguiente

Planificación de Procesos ( Políticas )


Planificación de Procesos ( Por niveles )

Planificación amedio plazo

Memoria

Planificación acorto plazo CPU

CPU

IT2

T2

T3

T5

T1, T2, T3, T4, T5, T6

S.O.

Entrada al sistema

frecuencia alta frecuencia baja


Planificación de Procesos ( Primero en llegar FCFS )Sólo cuando un proceso abandona voluntariamente la CPU, la misma se asigna al proceso que lleva más tiempo preparado (FIFO)

D C AB A D BCD BC

A E/S

Sencillo, pero Ausencia de política

D C B A

4 4 4 8

D C BA

8 4 4 4

Tesp

Tret

9

14

Tesp

Tret

6

11 “Efecto convoy”

{PE/S}n PUCP

PE/S {PE/S}n-1

PUCP

E/S

T >>T <


Planificación de Procesos ( Efecto convoy )

PUCP = {10UCP + 2E/S}* PE/S = {1UCP + 2 E/S}*

PUCP

PE/S

CPU al 100%, pero tan sólo 30 unidades de tiempo en E/S

CPU al 100% y además, 55 unidades de tiempo en E/S

PUCP

PE/S

??


Planificación de Procesos ( El más corto primero SJF )

Objetivo: Minimizar Tesp/ret 85

43 CPU

3458

¿Óptimo?¿Dónde esperan los procesos?

CPUpreparados

¿Aplicable SJF en planificación a largo y a

corto plazo?

¿Más corto?

• Tiempo total de CPU

• Lo declara el usuario

• Si engaña KILL

¿Más corto? Sistemas interactivos

Contraejemplo

0 1 2 3 4

A(2)B(4)

C(1)D(1)E(1)


• Variante expulsora del SJF.

• Cuando llega un trabajo nuevo, comparar su petición de tiempo

con el tiempo que le queda al actual. Seleccionar el menor.

• Favorece a los trabajos nuevos

0 1 2 3 4 5 6 7

A(2)B(4)

C(1)D(1)E(1)

¿Tiempo medio de espera?

Planificación de Procesos ( Tiempo restante menor SRTN )


Planificación de Procesos (Round Robin)“Todos iguales”: Turno Rotatorio o Rodajas de Tiempo

• A cada Pi que pasa a ejecución se le dá una rodaja “cuanto” de tiempo

a La consume totalmente y se le expulsa

Pi

rodaja

b La usa parcialmente y abandona voluntariamente la UCP

Pi

sleep, wait, exit

• Política FIFO de gestión de la cola de preparados

• Dos cuestiones de diseño:

1 ¿Cómo elegir el tamaño de la rodaja?

2 ¿Cómo determinar el fin de rodaja?

Ley del 80%


Planificación de Procesos (Round Robin)1 ¿Cómo elegir el tamaño de la rodaja? Sea Tcc = 5 mseg (mucho)

a Rodaja pequeña 20 mseg => Burocracia del 20%

b Rodaja grande 500 mseg => Burocracia del 1%

UCP útilRespuesta lenta ausuarios interactivos

¿Degenera en FCFS?Mejor

interactividad

• Ejemplo: P1, P2, P3 => 24, 3 y 3. Rodajas 4 vs 12 y Tcc = 0,5

P1 P2 P3 P1 P1 P1 P1 P1

33,5

P1 P2 P3 P1

31,5

Valores comunes:

20..50 mseg


Planificación de Procesos (Round Robin)2 ¿Cómo determinar el fin de rodaja?

a Una interrupción periódica

P1 P2 P3 P4

sleep

¿Somos justos con P3?

¿viable? F(int) en 68901 [1µseg..20mseg]

• Dar 2 rodajas• Resetear interrupción

b Sumar ticks de una interrupción más frecuente

P1 P2

sleep

P3 P4


Planificación de Procesos (Prioridades)“Unos más importantes que otros”: Cada Pi prioridad explícita

0 N

N 0mín

máx

expulsora

P3

P7

P1

UCP siempre ejecuta Pi más prioritario UCP libre ejecutar Pi más prioritario

• Igualdad de prioridad FCFS, Round Robin

• Prioridades estáticas vs dinámicas

Sencillo pero inaniciónP3

P7

P1

P9

¿ tiempo real ?

no expulsora

P3

P7

P1


Planificación de Procesos (Prioridades dinámicas)

a Evitar la inanición:

Disminuir la prioridad a medida que se usa la UCP

Aumentar la prioridad si se está tiempo en preparados

¿ Favorece a los trabajos cortos ?

b PE/S vs PUCPFavorece a los Pi ligados a E/S

• ¿Cuáles son PE/S?

• ¿Todo el tiempo será PE/S?

PE/S aquellos que usen una parte menor de la rodaja de UCP

Ejemplo con rodajas de 100 mseg:

P1 usa 2 mseg de UCP PE/S

P2 usa 25 mseg de UCP PUCP

Prio (P1) = 100/2 = 50

Prio (P2) = 100/25 = 4

¿Rango de prioridades [0..N]?Estáticas muy bajo 16

Dinámicas muy variable


Planificación de Procesos (Múltiples colas)

“Mezcla de políticas”: Cada Pi asociado a una cola de forma estática

Prioridad

3

2

1

0

FCFS

RoundRobin

Quantum

4

8

16

Dos elecciones:

1 Seleccionar cola

2 Seleccionar proceso dentro de la cola

¿Expulsora?


Planificación de Procesos (Múltiples colas realimentadas)

“Mezcla de políticas”: Cada Pi asociado a una cola de forma dinámica

a Menos Cambios de Contexto

Prioridad

4

3

2

1

0

1

+ Rodajas Variables

2

4

8

16

Rodajas para Pi 1, 2, 4, 8, 16

b Favorecer selectivamente PE/S

Prioridad

3 Terminal

2 E/S

1 Rodaja corta

0 Rodaja larga

Consumir rodajas:Bajar de prioridad

86

Planificación de Procesos (MINIX 3)

/usr/src/kernel/proc.h

Pi

SI consumió su rodaja Nueva rodaja Prioridad++ ¡Menor! Encolar_Al_FinalSINO Encolar_Al_Principio

sched

Preparados

MaxPrioridad

MinPrioridad

RoundRobin

proc[log].p_nextready


Planificación de Procesos ( Pi más corto siguiente SPN )

CPUpreparados

¿Más corto? ¿Más corto?SJF SPN

Tiempo de próxima posesión de UCP

?

¿Predicción? (i) i+1 = F (ti, i)

i+1 = ti + (1- ) i y = 1/2

Predicción

i ti

10

6

8

4

6

6

6

4

5

13

9

13

11

13

12


1

1m

i

i i

C

P

Dado

• m eventos periódicos

• evento i ocurre en el periodo Pi y precisa Ci segundos

El sistema es planificable si

Hard real time vs Soft real time

Eventos: periódicos vs aperiódicos

(Leer las secciones 7.4.2, 7.4.3 y 7.4.4)

Planificación de Procesos ( Sistemas de Tiempo Real )


Separar qué se puede hacer de cómo hacerlo• Un proceso puede saber cuáles de sus threads hijos son

los más importantes y asignarles prioridad

Algoritmo de planificación parametrizado• Mecanismo en el kernel

Los procesos de usuario ponen el valor de los parámetros• Los procesos de usuario indican la política

Planificación de Procesos ( Política vs Mecanismo )

pthread_attr_setschedpolicy(…) => FIFO, RR, OTHERS


Quantum por proceso de 50 msegCada thread ejecuta 5 mseg de ráfaga de CPU

Planificación de Threads ( Espacio de usuario )


Planificación de Threads ( Espacio de kernel )

Quantum por proceso de 50 msegCada thread ejecuta 5 mseg de ráfaga de CPU


Sistemas multiprocesador

µP1 µP2 µP3 µP4 Cada µP su cola

Peligro de carga desequilibrada

µP1 µP2 µP3 µP4

¡ Ojo ! Spin Lock

Planificar ¿Qué thread? ¿En qué núcleo?

1. Tiempo compartido Threads independientes Cola única

No escalable con aumento núcleos

Espera activa si FR Spin Lock

¡Estoy en RC! Alarga rodaja

Problemática caches Afinidad


Sistemas multiprocesador Ordenando 128.000 claves “burbuja” en Intel Core 2 Quad Q6600 2,46GHz

µP0

4MB L2

µP1 µP2

4MB L2

µP3

sched_setaffinity



2. Espacio compartido Threads cooperantes Apropiarse {µP}n

Núcleo ocioso cuando Pi.bloqueado

Sin multiprogramación ¡Menos burocracia!

Sin “n” núcleos libres no me ejecuto

Servidor Web con {threads} variable



3. Planificar por pandillas Threads cooperantesTiempo/Espacio

Espacio compartido

Tiempo compartido FIN

Documents

Gestión de Procesos1 Horas 1INTRODUCCIÓN4 2PROCESOS Y THREADS10 3GESTIÓN DE MEMORIA8 4ENTRADA / SALIDA2 5SISTEMA DE FICHEROS6 sisOpeTemarioCurso: 15/16